git.itanic.dy.fi Git - linux-stable/blob - drivers/net/ethernet/mediatek/mtk_eth_soc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *
   4  *   Copyright (C) 2009-2016 John Crispin <blogic@openwrt.org>
   5  *   Copyright (C) 2009-2016 Felix Fietkau <nbd@openwrt.org>
   6  *   Copyright (C) 2013-2016 Michael Lee <igvtee@gmail.com>
   7  */
   8
   9 #include <linux/of_device.h>
  10 #include <linux/of_mdio.h>
  11 #include <linux/of_net.h>
  12 #include <linux/of_address.h>
  13 #include <linux/mfd/syscon.h>
  14 #include <linux/regmap.h>
  15 #include <linux/clk.h>
  16 #include <linux/pm_runtime.h>
  17 #include <linux/if_vlan.h>
  18 #include <linux/reset.h>
  19 #include <linux/tcp.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/pinctrl/devinfo.h>
  22 #include <linux/phylink.h>
  23 #include <linux/jhash.h>
  24 #include <linux/bitfield.h>
  25 #include <net/dsa.h>
  26 #include <net/dst_metadata.h>
  27
  28 #include "mtk_eth_soc.h"
  29 #include "mtk_wed.h"
  30
  31 static int mtk_msg_level = -1;
  32 module_param_named(msg_level, mtk_msg_level, int, 0);
  33 MODULE_PARM_DESC(msg_level, "Message level (-1=defaults,0=none,...,16=all)");
  34
  35 #define MTK_ETHTOOL_STAT(x) { #x, \
  36                               offsetof(struct mtk_hw_stats, x) / sizeof(u64) }
  37
  38 #define MTK_ETHTOOL_XDP_STAT(x) { #x, \
  39                                   offsetof(struct mtk_hw_stats, xdp_stats.x) / \
  40                                   sizeof(u64) }
  41
  42 static const struct mtk_reg_map mtk_reg_map = {
  43         .tx_irq_mask            = 0x1a1c,
  44         .tx_irq_status          = 0x1a18,
  45         .pdma = {
  46                 .rx_ptr         = 0x0900,
  47                 .rx_cnt_cfg     = 0x0904,
  48                 .pcrx_ptr       = 0x0908,
  49                 .glo_cfg        = 0x0a04,
  50                 .rst_idx        = 0x0a08,
  51                 .delay_irq      = 0x0a0c,
  52                 .irq_status     = 0x0a20,
  53                 .irq_mask       = 0x0a28,
  54                 .adma_rx_dbg0   = 0x0a38,
  55                 .int_grp        = 0x0a50,
  56         },
  57         .qdma = {
  58                 .qtx_cfg        = 0x1800,
  59                 .qtx_sch        = 0x1804,
  60                 .rx_ptr         = 0x1900,
  61                 .rx_cnt_cfg     = 0x1904,
  62                 .qcrx_ptr       = 0x1908,
  63                 .glo_cfg        = 0x1a04,
  64                 .rst_idx        = 0x1a08,
  65                 .delay_irq      = 0x1a0c,
  66                 .fc_th          = 0x1a10,
  67                 .tx_sch_rate    = 0x1a14,
  68                 .int_grp        = 0x1a20,
  69                 .hred           = 0x1a44,
  70                 .ctx_ptr        = 0x1b00,
  71                 .dtx_ptr        = 0x1b04,
  72                 .crx_ptr        = 0x1b10,
  73                 .drx_ptr        = 0x1b14,
  74                 .fq_head        = 0x1b20,
  75                 .fq_tail        = 0x1b24,
  76                 .fq_count       = 0x1b28,
  77                 .fq_blen        = 0x1b2c,
  78         },
  79         .gdm1_cnt               = 0x2400,
  80         .gdma_to_ppe            = 0x4444,
  81         .ppe_base               = 0x0c00,
  82         .wdma_base = {
  83                 [0]             = 0x2800,
  84                 [1]             = 0x2c00,
  85         },
  86         .pse_iq_sta             = 0x0110,
  87         .pse_oq_sta             = 0x0118,
  88 };
  89
  90 static const struct mtk_reg_map mt7628_reg_map = {
  91         .tx_irq_mask            = 0x0a28,
  92         .tx_irq_status          = 0x0a20,
  93         .pdma = {
  94                 .rx_ptr         = 0x0900,
  95                 .rx_cnt_cfg     = 0x0904,
  96                 .pcrx_ptr       = 0x0908,
  97                 .glo_cfg        = 0x0a04,
  98                 .rst_idx        = 0x0a08,
  99                 .delay_irq      = 0x0a0c,
 100                 .irq_status     = 0x0a20,
 101                 .irq_mask       = 0x0a28,
 102                 .int_grp        = 0x0a50,
 103         },
 104 };
 105
 106 static const struct mtk_reg_map mt7986_reg_map = {
 107         .tx_irq_mask            = 0x461c,
 108         .tx_irq_status          = 0x4618,
 109         .pdma = {
 110                 .rx_ptr         = 0x6100,
 111                 .rx_cnt_cfg     = 0x6104,
 112                 .pcrx_ptr       = 0x6108,
 113                 .glo_cfg        = 0x6204,
 114                 .rst_idx        = 0x6208,
 115                 .delay_irq      = 0x620c,
 116                 .irq_status     = 0x6220,
 117                 .irq_mask       = 0x6228,
 118                 .adma_rx_dbg0   = 0x6238,
 119                 .int_grp        = 0x6250,
 120         },
 121         .qdma = {
 122                 .qtx_cfg        = 0x4400,
 123                 .qtx_sch        = 0x4404,
 124                 .rx_ptr         = 0x4500,
 125                 .rx_cnt_cfg     = 0x4504,
 126                 .qcrx_ptr       = 0x4508,
 127                 .glo_cfg        = 0x4604,
 128                 .rst_idx        = 0x4608,
 129                 .delay_irq      = 0x460c,
 130                 .fc_th          = 0x4610,
 131                 .int_grp        = 0x4620,
 132                 .hred           = 0x4644,
 133                 .ctx_ptr        = 0x4700,
 134                 .dtx_ptr        = 0x4704,
 135                 .crx_ptr        = 0x4710,
 136                 .drx_ptr        = 0x4714,
 137                 .fq_head        = 0x4720,
 138                 .fq_tail        = 0x4724,
 139                 .fq_count       = 0x4728,
 140                 .fq_blen        = 0x472c,
 141                 .tx_sch_rate    = 0x4798,
 142         },
 143         .gdm1_cnt               = 0x1c00,
 144         .gdma_to_ppe            = 0x3333,
 145         .ppe_base               = 0x2000,
 146         .wdma_base = {
 147                 [0]             = 0x4800,
 148                 [1]             = 0x4c00,
 149         },
 150         .pse_iq_sta             = 0x0180,
 151         .pse_oq_sta             = 0x01a0,
 152 };
 153
 154 /* strings used by ethtool */
 155 static const struct mtk_ethtool_stats {
 156         char str[ETH_GSTRING_LEN];
 157         u32 offset;
 158 } mtk_ethtool_stats[] = {
 159         MTK_ETHTOOL_STAT(tx_bytes),
 160         MTK_ETHTOOL_STAT(tx_packets),
 161         MTK_ETHTOOL_STAT(tx_skip),
 162         MTK_ETHTOOL_STAT(tx_collisions),
 163         MTK_ETHTOOL_STAT(rx_bytes),
 164         MTK_ETHTOOL_STAT(rx_packets),
 165         MTK_ETHTOOL_STAT(rx_overflow),
 166         MTK_ETHTOOL_STAT(rx_fcs_errors),
 167         MTK_ETHTOOL_STAT(rx_short_errors),
 168         MTK_ETHTOOL_STAT(rx_long_errors),
 169         MTK_ETHTOOL_STAT(rx_checksum_errors),
 170         MTK_ETHTOOL_STAT(rx_flow_control_packets),
 171         MTK_ETHTOOL_XDP_STAT(rx_xdp_redirect),
 172         MTK_ETHTOOL_XDP_STAT(rx_xdp_pass),
 173         MTK_ETHTOOL_XDP_STAT(rx_xdp_drop),
 174         MTK_ETHTOOL_XDP_STAT(rx_xdp_tx),
 175         MTK_ETHTOOL_XDP_STAT(rx_xdp_tx_errors),
 176         MTK_ETHTOOL_XDP_STAT(tx_xdp_xmit),
 177         MTK_ETHTOOL_XDP_STAT(tx_xdp_xmit_errors),
 178 };
 179
 180 static const char * const mtk_clks_source_name[] = {
 181         "ethif", "sgmiitop", "esw", "gp0", "gp1", "gp2", "fe", "trgpll",
 182         "sgmii_tx250m", "sgmii_rx250m", "sgmii_cdr_ref", "sgmii_cdr_fb",
 183         "sgmii2_tx250m", "sgmii2_rx250m", "sgmii2_cdr_ref", "sgmii2_cdr_fb",
 184         "sgmii_ck", "eth2pll", "wocpu0", "wocpu1", "netsys0", "netsys1"
 185 };
 186
 187 void mtk_w32(struct mtk_eth *eth, u32 val, unsigned reg)
 188 {
 189         __raw_writel(val, eth->base + reg);
 190 }
 191
 192 u32 mtk_r32(struct mtk_eth *eth, unsigned reg)
 193 {
 194         return __raw_readl(eth->base + reg);
 195 }
 196
 197 static u32 mtk_m32(struct mtk_eth *eth, u32 mask, u32 set, unsigned reg)
 198 {
 199         u32 val;
 200
 201         val = mtk_r32(eth, reg);
 202         val &= ~mask;
 203         val |= set;
 204         mtk_w32(eth, val, reg);
 205         return reg;
 206 }
 207
 208 static int mtk_mdio_busy_wait(struct mtk_eth *eth)
 209 {
 210         unsigned long t_start = jiffies;
 211
 212         while (1) {
 213                 if (!(mtk_r32(eth, MTK_PHY_IAC) & PHY_IAC_ACCESS))
 214                         return 0;
 215                 if (time_after(jiffies, t_start + PHY_IAC_TIMEOUT))
 216                         break;
 217                 cond_resched();
 218         }
 219
 220         dev_err(eth->dev, "mdio: MDIO timeout\n");
 221         return -ETIMEDOUT;
 222 }
 223
 224 static int _mtk_mdio_write_c22(struct mtk_eth *eth, u32 phy_addr, u32 phy_reg,
 225                                u32 write_data)
 226 {
 227         int ret;
 228
 229         ret = mtk_mdio_busy_wait(eth);
 230         if (ret < 0)
 231                 return ret;
 232
 233         mtk_w32(eth, PHY_IAC_ACCESS |
 234                 PHY_IAC_START_C22 |
 235                 PHY_IAC_CMD_WRITE |
 236                 PHY_IAC_REG(phy_reg) |
 237                 PHY_IAC_ADDR(phy_addr) |
 238                 PHY_IAC_DATA(write_data),
 239                 MTK_PHY_IAC);
 240
 241         ret = mtk_mdio_busy_wait(eth);
 242         if (ret < 0)
 243                 return ret;
 244
 245         return 0;
 246 }
 247
 248 static int _mtk_mdio_write_c45(struct mtk_eth *eth, u32 phy_addr,
 249                                u32 devad, u32 phy_reg, u32 write_data)
 250 {
 251         int ret;
 252
 253         ret = mtk_mdio_busy_wait(eth);
 254         if (ret < 0)
 255                 return ret;
 256
 257         mtk_w32(eth, PHY_IAC_ACCESS |
 258                 PHY_IAC_START_C45 |
 259                 PHY_IAC_CMD_C45_ADDR |
 260                 PHY_IAC_REG(devad) |
 261                 PHY_IAC_ADDR(phy_addr) |
 262                 PHY_IAC_DATA(phy_reg),
 263                 MTK_PHY_IAC);
 264
 265         ret = mtk_mdio_busy_wait(eth);
 266         if (ret < 0)
 267                 return ret;
 268
 269         mtk_w32(eth, PHY_IAC_ACCESS |
 270                 PHY_IAC_START_C45 |
 271                 PHY_IAC_CMD_WRITE |
 272                 PHY_IAC_REG(devad) |
 273                 PHY_IAC_ADDR(phy_addr) |
 274                 PHY_IAC_DATA(write_data),
 275                 MTK_PHY_IAC);
 276
 277         ret = mtk_mdio_busy_wait(eth);
 278         if (ret < 0)
 279                 return ret;
 280
 281         return 0;
 282 }
 283
 284 static int _mtk_mdio_read_c22(struct mtk_eth *eth, u32 phy_addr, u32 phy_reg)
 285 {
 286         int ret;
 287
 288         ret = mtk_mdio_busy_wait(eth);
 289         if (ret < 0)
 290                 return ret;
 291
 292         mtk_w32(eth, PHY_IAC_ACCESS |
 293                 PHY_IAC_START_C22 |
 294                 PHY_IAC_CMD_C22_READ |
 295                 PHY_IAC_REG(phy_reg) |
 296                 PHY_IAC_ADDR(phy_addr),
 297                 MTK_PHY_IAC);
 298
 299         ret = mtk_mdio_busy_wait(eth);
 300         if (ret < 0)
 301                 return ret;
 302
 303         return mtk_r32(eth, MTK_PHY_IAC) & PHY_IAC_DATA_MASK;
 304 }
 305
 306 static int _mtk_mdio_read_c45(struct mtk_eth *eth, u32 phy_addr,
 307                               u32 devad, u32 phy_reg)
 308 {
 309         int ret;
 310
 311         ret = mtk_mdio_busy_wait(eth);
 312         if (ret < 0)
 313                 return ret;
 314
 315         mtk_w32(eth, PHY_IAC_ACCESS |
 316                 PHY_IAC_START_C45 |
 317                 PHY_IAC_CMD_C45_ADDR |
 318                 PHY_IAC_REG(devad) |
 319                 PHY_IAC_ADDR(phy_addr) |
 320                 PHY_IAC_DATA(phy_reg),
 321                 MTK_PHY_IAC);
 322
 323         ret = mtk_mdio_busy_wait(eth);
 324         if (ret < 0)
 325                 return ret;
 326
 327         mtk_w32(eth, PHY_IAC_ACCESS |
 328                 PHY_IAC_START_C45 |
 329                 PHY_IAC_CMD_C45_READ |
 330                 PHY_IAC_REG(devad) |
 331                 PHY_IAC_ADDR(phy_addr),
 332                 MTK_PHY_IAC);
 333
 334         ret = mtk_mdio_busy_wait(eth);
 335         if (ret < 0)
 336                 return ret;
 337
 338         return mtk_r32(eth, MTK_PHY_IAC) & PHY_IAC_DATA_MASK;
 339 }
 340
 341 static int mtk_mdio_write_c22(struct mii_bus *bus, int phy_addr,
 342                               int phy_reg, u16 val)
 343 {
 344         struct mtk_eth *eth = bus->priv;
 345
 346         return _mtk_mdio_write_c22(eth, phy_addr, phy_reg, val);
 347 }
 348
 349 static int mtk_mdio_write_c45(struct mii_bus *bus, int phy_addr,
 350                               int devad, int phy_reg, u16 val)
 351 {
 352         struct mtk_eth *eth = bus->priv;
 353
 354         return _mtk_mdio_write_c45(eth, phy_addr, devad, phy_reg, val);
 355 }
 356
 357 static int mtk_mdio_read_c22(struct mii_bus *bus, int phy_addr, int phy_reg)
 358 {
 359         struct mtk_eth *eth = bus->priv;
 360
 361         return _mtk_mdio_read_c22(eth, phy_addr, phy_reg);
 362 }
 363
 364 static int mtk_mdio_read_c45(struct mii_bus *bus, int phy_addr, int devad,
 365                              int phy_reg)
 366 {
 367         struct mtk_eth *eth = bus->priv;
 368
 369         return _mtk_mdio_read_c45(eth, phy_addr, devad, phy_reg);
 370 }
 371
 372 static int mt7621_gmac0_rgmii_adjust(struct mtk_eth *eth,
 373                                      phy_interface_t interface)
 374 {
 375         u32 val;
 376
 377         /* Check DDR memory type.
 378          * Currently TRGMII mode with DDR2 memory is not supported.
 379          */
 380         regmap_read(eth->ethsys, ETHSYS_SYSCFG, &val);
 381         if (interface == PHY_INTERFACE_MODE_TRGMII &&
 382             val & SYSCFG_DRAM_TYPE_DDR2) {
 383                 dev_err(eth->dev,
 384                         "TRGMII mode with DDR2 memory is not supported!\n");
 385                 return -EOPNOTSUPP;
 386         }
 387
 388         val = (interface == PHY_INTERFACE_MODE_TRGMII) ?
 389                 ETHSYS_TRGMII_MT7621_DDR_PLL : 0;
 390
 391         regmap_update_bits(eth->ethsys, ETHSYS_CLKCFG0,
 392                            ETHSYS_TRGMII_MT7621_MASK, val);
 393
 394         return 0;
 395 }
 396
 397 static void mtk_gmac0_rgmii_adjust(struct mtk_eth *eth,
 398                                    phy_interface_t interface, int speed)
 399 {
 400         u32 val;
 401         int ret;
 402
 403         if (interface == PHY_INTERFACE_MODE_TRGMII) {
 404                 mtk_w32(eth, TRGMII_MODE, INTF_MODE);
 405                 val = 500000000;
 406                 ret = clk_set_rate(eth->clks[MTK_CLK_TRGPLL], val);
 407                 if (ret)
 408                         dev_err(eth->dev, "Failed to set trgmii pll: %d\n", ret);
 409                 return;
 410         }
 411
 412         val = (speed == SPEED_1000) ?
 413                 INTF_MODE_RGMII_1000 : INTF_MODE_RGMII_10_100;
 414         mtk_w32(eth, val, INTF_MODE);
 415
 416         regmap_update_bits(eth->ethsys, ETHSYS_CLKCFG0,
 417                            ETHSYS_TRGMII_CLK_SEL362_5,
 418                            ETHSYS_TRGMII_CLK_SEL362_5);
 419
 420         val = (speed == SPEED_1000) ? 250000000 : 500000000;
 421         ret = clk_set_rate(eth->clks[MTK_CLK_TRGPLL], val);
 422         if (ret)
 423                 dev_err(eth->dev, "Failed to set trgmii pll: %d\n", ret);
 424
 425         val = (speed == SPEED_1000) ?
 426                 RCK_CTRL_RGMII_1000 : RCK_CTRL_RGMII_10_100;
 427         mtk_w32(eth, val, TRGMII_RCK_CTRL);
 428
 429         val = (speed == SPEED_1000) ?
 430                 TCK_CTRL_RGMII_1000 : TCK_CTRL_RGMII_10_100;
 431         mtk_w32(eth, val, TRGMII_TCK_CTRL);
 432 }
 433
 434 static struct phylink_pcs *mtk_mac_select_pcs(struct phylink_config *config,
 435                                               phy_interface_t interface)
 436 {
 437         struct mtk_mac *mac = container_of(config, struct mtk_mac,
 438                                            phylink_config);
 439         struct mtk_eth *eth = mac->hw;
 440         unsigned int sid;
 441
 442         if (interface == PHY_INTERFACE_MODE_SGMII ||
 443             phy_interface_mode_is_8023z(interface)) {
 444                 sid = (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_SGMII)) ?
 445                        0 : mac->id;
 446
 447                 return mtk_sgmii_select_pcs(eth->sgmii, sid);
 448         }
 449
 450         return NULL;
 451 }
 452
 453 static void mtk_mac_config(struct phylink_config *config, unsigned int mode,
 454                            const struct phylink_link_state *state)
 455 {
 456         struct mtk_mac *mac = container_of(config, struct mtk_mac,
 457                                            phylink_config);
 458         struct mtk_eth *eth = mac->hw;
 459         int val, ge_mode, err = 0;
 460         u32 i;
 461
 462         /* MT76x8 has no hardware settings between for the MAC */
 463         if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628) &&
 464             mac->interface != state->interface) {
 465                 /* Setup soc pin functions */
 466                 switch (state->interface) {
 467                 case PHY_INTERFACE_MODE_TRGMII:
 468                         if (mac->id)
 469                                 goto err_phy;
 470                         if (!MTK_HAS_CAPS(mac->hw->soc->caps,
 471                                           MTK_GMAC1_TRGMII))
 472                                 goto err_phy;
 473                         fallthrough;
 474                 case PHY_INTERFACE_MODE_RGMII_TXID:
 475                 case PHY_INTERFACE_MODE_RGMII_RXID:
 476                 case PHY_INTERFACE_MODE_RGMII_ID:
 477                 case PHY_INTERFACE_MODE_RGMII:
 478                 case PHY_INTERFACE_MODE_MII:
 479                 case PHY_INTERFACE_MODE_REVMII:
 480                 case PHY_INTERFACE_MODE_RMII:
 481                         if (MTK_HAS_CAPS(eth->soc->caps, MTK_RGMII)) {
 482                                 err = mtk_gmac_rgmii_path_setup(eth, mac->id);
 483                                 if (err)
 484                                         goto init_err;
 485                         }
 486                         break;
 487                 case PHY_INTERFACE_MODE_1000BASEX:
 488                 case PHY_INTERFACE_MODE_2500BASEX:
 489                 case PHY_INTERFACE_MODE_SGMII:
 490                         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII)) {
 491                                 err = mtk_gmac_sgmii_path_setup(eth, mac->id);
 492                                 if (err)
 493                                         goto init_err;
 494                         }
 495                         break;
 496                 case PHY_INTERFACE_MODE_GMII:
 497                         if (MTK_HAS_CAPS(eth->soc->caps, MTK_GEPHY)) {
 498                                 err = mtk_gmac_gephy_path_setup(eth, mac->id);
 499                                 if (err)
 500                                         goto init_err;
 501                         }
 502                         break;
 503                 default:
 504                         goto err_phy;
 505                 }
 506
 507                 /* Setup clock for 1st gmac */
 508                 if (!mac->id && state->interface != PHY_INTERFACE_MODE_SGMII &&
 509                     !phy_interface_mode_is_8023z(state->interface) &&
 510                     MTK_HAS_CAPS(mac->hw->soc->caps, MTK_GMAC1_TRGMII)) {
 511                         if (MTK_HAS_CAPS(mac->hw->soc->caps,
 512                                          MTK_TRGMII_MT7621_CLK)) {
 513                                 if (mt7621_gmac0_rgmii_adjust(mac->hw,
 514                                                               state->interface))
 515                                         goto err_phy;
 516                         } else {
 517                                 /* FIXME: this is incorrect. Not only does it
 518                                  * use state->speed (which is not guaranteed
 519                                  * to be correct) but it also makes use of it
 520                                  * in a code path that will only be reachable
 521                                  * when the PHY interface mode changes, not
 522                                  * when the speed changes. Consequently, RGMII
 523                                  * is probably broken.
 524                                  */
 525                                 mtk_gmac0_rgmii_adjust(mac->hw,
 526                                                        state->interface,
 527                                                        state->speed);
 528
 529                                 /* mt7623_pad_clk_setup */
 530                                 for (i = 0 ; i < NUM_TRGMII_CTRL; i++)
 531                                         mtk_w32(mac->hw,
 532                                                 TD_DM_DRVP(8) | TD_DM_DRVN(8),
 533                                                 TRGMII_TD_ODT(i));
 534
 535                                 /* Assert/release MT7623 RXC reset */
 536                                 mtk_m32(mac->hw, 0, RXC_RST | RXC_DQSISEL,
 537                                         TRGMII_RCK_CTRL);
 538                                 mtk_m32(mac->hw, RXC_RST, 0, TRGMII_RCK_CTRL);
 539                         }
 540                 }
 541
 542                 ge_mode = 0;
 543                 switch (state->interface) {
 544                 case PHY_INTERFACE_MODE_MII:
 545                 case PHY_INTERFACE_MODE_GMII:
 546                         ge_mode = 1;
 547                         break;
 548                 case PHY_INTERFACE_MODE_REVMII:
 549                         ge_mode = 2;
 550                         break;
 551                 case PHY_INTERFACE_MODE_RMII:
 552                         if (mac->id)
 553                                 goto err_phy;
 554                         ge_mode = 3;
 555                         break;
 556                 default:
 557                         break;
 558                 }
 559
 560                 /* put the gmac into the right mode */
 561                 regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val);
 562                 val &= ~SYSCFG0_GE_MODE(SYSCFG0_GE_MASK, mac->id);
 563                 val |= SYSCFG0_GE_MODE(ge_mode, mac->id);
 564                 regmap_write(eth->ethsys, ETHSYS_SYSCFG0, val);
 565
 566                 mac->interface = state->interface;
 567         }
 568
 569         /* SGMII */
 570         if (state->interface == PHY_INTERFACE_MODE_SGMII ||
 571             phy_interface_mode_is_8023z(state->interface)) {
 572                 /* The path GMAC to SGMII will be enabled once the SGMIISYS is
 573                  * being setup done.
 574                  */
 575                 regmap_read(eth->ethsys, ETHSYS_SYSCFG0, &val);
 576
 577                 regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0,
 578                                    SYSCFG0_SGMII_MASK,
 579                                    ~(u32)SYSCFG0_SGMII_MASK);
 580
 581                 /* Save the syscfg0 value for mac_finish */
 582                 mac->syscfg0 = val;
 583         } else if (phylink_autoneg_inband(mode)) {
 584                 dev_err(eth->dev,
 585                         "In-band mode not supported in non SGMII mode!\n");
 586                 return;
 587         }
 588
 589         return;
 590
 591 err_phy:
 592         dev_err(eth->dev, "%s: GMAC%d mode %s not supported!\n", __func__,
 593                 mac->id, phy_modes(state->interface));
 594         return;
 595
 596 init_err:
 597         dev_err(eth->dev, "%s: GMAC%d mode %s err: %d!\n", __func__,
 598                 mac->id, phy_modes(state->interface), err);
 599 }
 600
 601 static int mtk_mac_finish(struct phylink_config *config, unsigned int mode,
 602                           phy_interface_t interface)
 603 {
 604         struct mtk_mac *mac = container_of(config, struct mtk_mac,
 605                                            phylink_config);
 606         struct mtk_eth *eth = mac->hw;
 607         u32 mcr_cur, mcr_new;
 608
 609         /* Enable SGMII */
 610         if (interface == PHY_INTERFACE_MODE_SGMII ||
 611             phy_interface_mode_is_8023z(interface))
 612                 regmap_update_bits(eth->ethsys, ETHSYS_SYSCFG0,
 613                                    SYSCFG0_SGMII_MASK, mac->syscfg0);
 614
 615         /* Setup gmac */
 616         mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
 617         mcr_new = mcr_cur;
 618         mcr_new |= MAC_MCR_IPG_CFG | MAC_MCR_FORCE_MODE |
 619                    MAC_MCR_BACKOFF_EN | MAC_MCR_BACKPR_EN | MAC_MCR_FORCE_LINK |
 620                    MAC_MCR_RX_FIFO_CLR_DIS;
 621
 622         /* Only update control register when needed! */
 623         if (mcr_new != mcr_cur)
 624                 mtk_w32(mac->hw, mcr_new, MTK_MAC_MCR(mac->id));
 625
 626         return 0;
 627 }
 628
 629 static void mtk_mac_pcs_get_state(struct phylink_config *config,
 630                                   struct phylink_link_state *state)
 631 {
 632         struct mtk_mac *mac = container_of(config, struct mtk_mac,
 633                                            phylink_config);
 634         u32 pmsr = mtk_r32(mac->hw, MTK_MAC_MSR(mac->id));
 635
 636         state->link = (pmsr & MAC_MSR_LINK);
 637         state->duplex = (pmsr & MAC_MSR_DPX) >> 1;
 638
 639         switch (pmsr & (MAC_MSR_SPEED_1000 | MAC_MSR_SPEED_100)) {
 640         case 0:
 641                 state->speed = SPEED_10;
 642                 break;
 643         case MAC_MSR_SPEED_100:
 644                 state->speed = SPEED_100;
 645                 break;
 646         case MAC_MSR_SPEED_1000:
 647                 state->speed = SPEED_1000;
 648                 break;
 649         default:
 650                 state->speed = SPEED_UNKNOWN;
 651                 break;
 652         }
 653
 654         state->pause &= (MLO_PAUSE_RX | MLO_PAUSE_TX);
 655         if (pmsr & MAC_MSR_RX_FC)
 656                 state->pause |= MLO_PAUSE_RX;
 657         if (pmsr & MAC_MSR_TX_FC)
 658                 state->pause |= MLO_PAUSE_TX;
 659 }
 660
 661 static void mtk_mac_link_down(struct phylink_config *config, unsigned int mode,
 662                               phy_interface_t interface)
 663 {
 664         struct mtk_mac *mac = container_of(config, struct mtk_mac,
 665                                            phylink_config);
 666         u32 mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
 667
 668         mcr &= ~(MAC_MCR_TX_EN | MAC_MCR_RX_EN);
 669         mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
 670 }
 671
 672 static void mtk_set_queue_speed(struct mtk_eth *eth, unsigned int idx,
 673                                 int speed)
 674 {
 675         const struct mtk_soc_data *soc = eth->soc;
 676         u32 ofs, val;
 677
 678         if (!MTK_HAS_CAPS(soc->caps, MTK_QDMA))
 679                 return;
 680
 681         val = MTK_QTX_SCH_MIN_RATE_EN |
 682               /* minimum: 10 Mbps */
 683               FIELD_PREP(MTK_QTX_SCH_MIN_RATE_MAN, 1) |
 684               FIELD_PREP(MTK_QTX_SCH_MIN_RATE_EXP, 4) |
 685               MTK_QTX_SCH_LEAKY_BUCKET_SIZE;
 686         if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
 687                 val |= MTK_QTX_SCH_LEAKY_BUCKET_EN;
 688
 689         if (IS_ENABLED(CONFIG_SOC_MT7621)) {
 690                 switch (speed) {
 691                 case SPEED_10:
 692                         val |= MTK_QTX_SCH_MAX_RATE_EN |
 693                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_MAN, 103) |
 694                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_EXP, 2) |
 695                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_WEIGHT, 1);
 696                         break;
 697                 case SPEED_100:
 698                         val |= MTK_QTX_SCH_MAX_RATE_EN |
 699                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_MAN, 103) |
 700                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_EXP, 3);
 701                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_WEIGHT, 1);
 702                         break;
 703                 case SPEED_1000:
 704                         val |= MTK_QTX_SCH_MAX_RATE_EN |
 705                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_MAN, 105) |
 706                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_EXP, 4) |
 707                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_WEIGHT, 10);
 708                         break;
 709                 default:
 710                         break;
 711                 }
 712         } else {
 713                 switch (speed) {
 714                 case SPEED_10:
 715                         val |= MTK_QTX_SCH_MAX_RATE_EN |
 716                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_MAN, 1) |
 717                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_EXP, 4) |
 718                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_WEIGHT, 1);
 719                         break;
 720                 case SPEED_100:
 721                         val |= MTK_QTX_SCH_MAX_RATE_EN |
 722                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_MAN, 1) |
 723                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_EXP, 5);
 724                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_WEIGHT, 1);
 725                         break;
 726                 case SPEED_1000:
 727                         val |= MTK_QTX_SCH_MAX_RATE_EN |
 728                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_MAN, 10) |
 729                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_EXP, 5) |
 730                                FIELD_PREP(MTK_QTX_SCH_MAX_RATE_WEIGHT, 10);
 731                         break;
 732                 default:
 733                         break;
 734                 }
 735         }
 736
 737         ofs = MTK_QTX_OFFSET * idx;
 738         mtk_w32(eth, val, soc->reg_map->qdma.qtx_sch + ofs);
 739 }
 740
 741 static void mtk_mac_link_up(struct phylink_config *config,
 742                             struct phy_device *phy,
 743                             unsigned int mode, phy_interface_t interface,
 744                             int speed, int duplex, bool tx_pause, bool rx_pause)
 745 {
 746         struct mtk_mac *mac = container_of(config, struct mtk_mac,
 747                                            phylink_config);
 748         u32 mcr;
 749
 750         mcr = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
 751         mcr &= ~(MAC_MCR_SPEED_100 | MAC_MCR_SPEED_1000 |
 752                  MAC_MCR_FORCE_DPX | MAC_MCR_FORCE_TX_FC |
 753                  MAC_MCR_FORCE_RX_FC);
 754
 755         /* Configure speed */
 756         mac->speed = speed;
 757         switch (speed) {
 758         case SPEED_2500:
 759         case SPEED_1000:
 760                 mcr |= MAC_MCR_SPEED_1000;
 761                 break;
 762         case SPEED_100:
 763                 mcr |= MAC_MCR_SPEED_100;
 764                 break;
 765         }
 766
 767         /* Configure duplex */
 768         if (duplex == DUPLEX_FULL)
 769                 mcr |= MAC_MCR_FORCE_DPX;
 770
 771         /* Configure pause modes - phylink will avoid these for half duplex */
 772         if (tx_pause)
 773                 mcr |= MAC_MCR_FORCE_TX_FC;
 774         if (rx_pause)
 775                 mcr |= MAC_MCR_FORCE_RX_FC;
 776
 777         mcr |= MAC_MCR_TX_EN | MAC_MCR_RX_EN;
 778         mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
 779 }
 780
 781 static const struct phylink_mac_ops mtk_phylink_ops = {
 782         .mac_select_pcs = mtk_mac_select_pcs,
 783         .mac_pcs_get_state = mtk_mac_pcs_get_state,
 784         .mac_config = mtk_mac_config,
 785         .mac_finish = mtk_mac_finish,
 786         .mac_link_down = mtk_mac_link_down,
 787         .mac_link_up = mtk_mac_link_up,
 788 };
 789
 790 static int mtk_mdio_init(struct mtk_eth *eth)
 791 {
 792         struct device_node *mii_np;
 793         int ret;
 794
 795         mii_np = of_get_child_by_name(eth->dev->of_node, "mdio-bus");
 796         if (!mii_np) {
 797                 dev_err(eth->dev, "no %s child node found", "mdio-bus");
 798                 return -ENODEV;
 799         }
 800
 801         if (!of_device_is_available(mii_np)) {
 802                 ret = -ENODEV;
 803                 goto err_put_node;
 804         }
 805
 806         eth->mii_bus = devm_mdiobus_alloc(eth->dev);
 807         if (!eth->mii_bus) {
 808                 ret = -ENOMEM;
 809                 goto err_put_node;
 810         }
 811
 812         eth->mii_bus->name = "mdio";
 813         eth->mii_bus->read = mtk_mdio_read_c22;
 814         eth->mii_bus->write = mtk_mdio_write_c22;
 815         eth->mii_bus->read_c45 = mtk_mdio_read_c45;
 816         eth->mii_bus->write_c45 = mtk_mdio_write_c45;
 817         eth->mii_bus->priv = eth;
 818         eth->mii_bus->parent = eth->dev;
 819
 820         snprintf(eth->mii_bus->id, MII_BUS_ID_SIZE, "%pOFn", mii_np);
 821         ret = of_mdiobus_register(eth->mii_bus, mii_np);
 822
 823 err_put_node:
 824         of_node_put(mii_np);
 825         return ret;
 826 }
 827
 828 static void mtk_mdio_cleanup(struct mtk_eth *eth)
 829 {
 830         if (!eth->mii_bus)
 831                 return;
 832
 833         mdiobus_unregister(eth->mii_bus);
 834 }
 835
 836 static inline void mtk_tx_irq_disable(struct mtk_eth *eth, u32 mask)
 837 {
 838         unsigned long flags;
 839         u32 val;
 840
 841         spin_lock_irqsave(&eth->tx_irq_lock, flags);
 842         val = mtk_r32(eth, eth->soc->reg_map->tx_irq_mask);
 843         mtk_w32(eth, val & ~mask, eth->soc->reg_map->tx_irq_mask);
 844         spin_unlock_irqrestore(&eth->tx_irq_lock, flags);
 845 }
 846
 847 static inline void mtk_tx_irq_enable(struct mtk_eth *eth, u32 mask)
 848 {
 849         unsigned long flags;
 850         u32 val;
 851
 852         spin_lock_irqsave(&eth->tx_irq_lock, flags);
 853         val = mtk_r32(eth, eth->soc->reg_map->tx_irq_mask);
 854         mtk_w32(eth, val | mask, eth->soc->reg_map->tx_irq_mask);
 855         spin_unlock_irqrestore(&eth->tx_irq_lock, flags);
 856 }
 857
 858 static inline void mtk_rx_irq_disable(struct mtk_eth *eth, u32 mask)
 859 {
 860         unsigned long flags;
 861         u32 val;
 862
 863         spin_lock_irqsave(&eth->rx_irq_lock, flags);
 864         val = mtk_r32(eth, eth->soc->reg_map->pdma.irq_mask);
 865         mtk_w32(eth, val & ~mask, eth->soc->reg_map->pdma.irq_mask);
 866         spin_unlock_irqrestore(&eth->rx_irq_lock, flags);
 867 }
 868
 869 static inline void mtk_rx_irq_enable(struct mtk_eth *eth, u32 mask)
 870 {
 871         unsigned long flags;
 872         u32 val;
 873
 874         spin_lock_irqsave(&eth->rx_irq_lock, flags);
 875         val = mtk_r32(eth, eth->soc->reg_map->pdma.irq_mask);
 876         mtk_w32(eth, val | mask, eth->soc->reg_map->pdma.irq_mask);
 877         spin_unlock_irqrestore(&eth->rx_irq_lock, flags);
 878 }
 879
 880 static int mtk_set_mac_address(struct net_device *dev, void *p)
 881 {
 882         int ret = eth_mac_addr(dev, p);
 883         struct mtk_mac *mac = netdev_priv(dev);
 884         struct mtk_eth *eth = mac->hw;
 885         const char *macaddr = dev->dev_addr;
 886
 887         if (ret)
 888                 return ret;
 889
 890         if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
 891                 return -EBUSY;
 892
 893         spin_lock_bh(&mac->hw->page_lock);
 894         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
 895                 mtk_w32(mac->hw, (macaddr[0] << 8) | macaddr[1],
 896                         MT7628_SDM_MAC_ADRH);
 897                 mtk_w32(mac->hw, (macaddr[2] << 24) | (macaddr[3] << 16) |
 898                         (macaddr[4] << 8) | macaddr[5],
 899                         MT7628_SDM_MAC_ADRL);
 900         } else {
 901                 mtk_w32(mac->hw, (macaddr[0] << 8) | macaddr[1],
 902                         MTK_GDMA_MAC_ADRH(mac->id));
 903                 mtk_w32(mac->hw, (macaddr[2] << 24) | (macaddr[3] << 16) |
 904                         (macaddr[4] << 8) | macaddr[5],
 905                         MTK_GDMA_MAC_ADRL(mac->id));
 906         }
 907         spin_unlock_bh(&mac->hw->page_lock);
 908
 909         return 0;
 910 }
 911
 912 void mtk_stats_update_mac(struct mtk_mac *mac)
 913 {
 914         struct mtk_hw_stats *hw_stats = mac->hw_stats;
 915         struct mtk_eth *eth = mac->hw;
 916
 917         u64_stats_update_begin(&hw_stats->syncp);
 918
 919         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
 920                 hw_stats->tx_packets += mtk_r32(mac->hw, MT7628_SDM_TPCNT);
 921                 hw_stats->tx_bytes += mtk_r32(mac->hw, MT7628_SDM_TBCNT);
 922                 hw_stats->rx_packets += mtk_r32(mac->hw, MT7628_SDM_RPCNT);
 923                 hw_stats->rx_bytes += mtk_r32(mac->hw, MT7628_SDM_RBCNT);
 924                 hw_stats->rx_checksum_errors +=
 925                         mtk_r32(mac->hw, MT7628_SDM_CS_ERR);
 926         } else {
 927                 const struct mtk_reg_map *reg_map = eth->soc->reg_map;
 928                 unsigned int offs = hw_stats->reg_offset;
 929                 u64 stats;
 930
 931                 hw_stats->rx_bytes += mtk_r32(mac->hw, reg_map->gdm1_cnt + offs);
 932                 stats = mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x4 + offs);
 933                 if (stats)
 934                         hw_stats->rx_bytes += (stats << 32);
 935                 hw_stats->rx_packets +=
 936                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x8 + offs);
 937                 hw_stats->rx_overflow +=
 938                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x10 + offs);
 939                 hw_stats->rx_fcs_errors +=
 940                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x14 + offs);
 941                 hw_stats->rx_short_errors +=
 942                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x18 + offs);
 943                 hw_stats->rx_long_errors +=
 944                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x1c + offs);
 945                 hw_stats->rx_checksum_errors +=
 946                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x20 + offs);
 947                 hw_stats->rx_flow_control_packets +=
 948                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x24 + offs);
 949                 hw_stats->tx_skip +=
 950                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x28 + offs);
 951                 hw_stats->tx_collisions +=
 952                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x2c + offs);
 953                 hw_stats->tx_bytes +=
 954                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x30 + offs);
 955                 stats =  mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x34 + offs);
 956                 if (stats)
 957                         hw_stats->tx_bytes += (stats << 32);
 958                 hw_stats->tx_packets +=
 959                         mtk_r32(mac->hw, reg_map->gdm1_cnt + 0x38 + offs);
 960         }
 961
 962         u64_stats_update_end(&hw_stats->syncp);
 963 }
 964
 965 static void mtk_stats_update(struct mtk_eth *eth)
 966 {
 967         int i;
 968
 969         for (i = 0; i < MTK_MAC_COUNT; i++) {
 970                 if (!eth->mac[i] || !eth->mac[i]->hw_stats)
 971                         continue;
 972                 if (spin_trylock(&eth->mac[i]->hw_stats->stats_lock)) {
 973                         mtk_stats_update_mac(eth->mac[i]);
 974                         spin_unlock(&eth->mac[i]->hw_stats->stats_lock);
 975                 }
 976         }
 977 }
 978
 979 static void mtk_get_stats64(struct net_device *dev,
 980                             struct rtnl_link_stats64 *storage)
 981 {
 982         struct mtk_mac *mac = netdev_priv(dev);
 983         struct mtk_hw_stats *hw_stats = mac->hw_stats;
 984         unsigned int start;
 985
 986         if (netif_running(dev) && netif_device_present(dev)) {
 987                 if (spin_trylock_bh(&hw_stats->stats_lock)) {
 988                         mtk_stats_update_mac(mac);
 989                         spin_unlock_bh(&hw_stats->stats_lock);
 990                 }
 991         }
 992
 993         do {
 994                 start = u64_stats_fetch_begin(&hw_stats->syncp);
 995                 storage->rx_packets = hw_stats->rx_packets;
 996                 storage->tx_packets = hw_stats->tx_packets;
 997                 storage->rx_bytes = hw_stats->rx_bytes;
 998                 storage->tx_bytes = hw_stats->tx_bytes;
 999                 storage->collisions = hw_stats->tx_collisions;
1000                 storage->rx_length_errors = hw_stats->rx_short_errors +
1001                         hw_stats->rx_long_errors;
1002                 storage->rx_over_errors = hw_stats->rx_overflow;
1003                 storage->rx_crc_errors = hw_stats->rx_fcs_errors;
1004                 storage->rx_errors = hw_stats->rx_checksum_errors;
1005                 storage->tx_aborted_errors = hw_stats->tx_skip;
1006         } while (u64_stats_fetch_retry(&hw_stats->syncp, start));
1007
1008         storage->tx_errors = dev->stats.tx_errors;
1009         storage->rx_dropped = dev->stats.rx_dropped;
1010         storage->tx_dropped = dev->stats.tx_dropped;
1011 }
1012
1013 static inline int mtk_max_frag_size(int mtu)
1014 {
1015         /* make sure buf_size will be at least MTK_MAX_RX_LENGTH */
1016         if (mtu + MTK_RX_ETH_HLEN < MTK_MAX_RX_LENGTH_2K)
1017                 mtu = MTK_MAX_RX_LENGTH_2K - MTK_RX_ETH_HLEN;
1018
1019         return SKB_DATA_ALIGN(MTK_RX_HLEN + mtu) +
1020                 SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
1021 }
1022
1023 static inline int mtk_max_buf_size(int frag_size)
1024 {
1025         int buf_size = frag_size - NET_SKB_PAD - NET_IP_ALIGN -
1026                        SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
1027
1028         WARN_ON(buf_size < MTK_MAX_RX_LENGTH_2K);
1029
1030         return buf_size;
1031 }
1032
1033 static bool mtk_rx_get_desc(struct mtk_eth *eth, struct mtk_rx_dma_v2 *rxd,
1034                             struct mtk_rx_dma_v2 *dma_rxd)
1035 {
1036         rxd->rxd2 = READ_ONCE(dma_rxd->rxd2);
1037         if (!(rxd->rxd2 & RX_DMA_DONE))
1038                 return false;
1039
1040         rxd->rxd1 = READ_ONCE(dma_rxd->rxd1);
1041         rxd->rxd3 = READ_ONCE(dma_rxd->rxd3);
1042         rxd->rxd4 = READ_ONCE(dma_rxd->rxd4);
1043         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
1044                 rxd->rxd5 = READ_ONCE(dma_rxd->rxd5);
1045                 rxd->rxd6 = READ_ONCE(dma_rxd->rxd6);
1046         }
1047
1048         return true;
1049 }
1050
1051 static void *mtk_max_lro_buf_alloc(gfp_t gfp_mask)
1052 {
1053         unsigned int size = mtk_max_frag_size(MTK_MAX_LRO_RX_LENGTH);
1054         unsigned long data;
1055
1056         data = __get_free_pages(gfp_mask | __GFP_COMP | __GFP_NOWARN,
1057                                 get_order(size));
1058
1059         return (void *)data;
1060 }
1061
1062 /* the qdma core needs scratch memory to be setup */
1063 static int mtk_init_fq_dma(struct mtk_eth *eth)
1064 {
1065         const struct mtk_soc_data *soc = eth->soc;
1066         dma_addr_t phy_ring_tail;
1067         int cnt = MTK_QDMA_RING_SIZE;
1068         dma_addr_t dma_addr;
1069         int i;
1070
1071         eth->scratch_ring = dma_alloc_coherent(eth->dma_dev,
1072                                                cnt * soc->txrx.txd_size,
1073                                                &eth->phy_scratch_ring,
1074                                                GFP_KERNEL);
1075         if (unlikely(!eth->scratch_ring))
1076                 return -ENOMEM;
1077
1078         eth->scratch_head = kcalloc(cnt, MTK_QDMA_PAGE_SIZE, GFP_KERNEL);
1079         if (unlikely(!eth->scratch_head))
1080                 return -ENOMEM;
1081
1082         dma_addr = dma_map_single(eth->dma_dev,
1083                                   eth->scratch_head, cnt * MTK_QDMA_PAGE_SIZE,
1084                                   DMA_FROM_DEVICE);
1085         if (unlikely(dma_mapping_error(eth->dma_dev, dma_addr)))
1086                 return -ENOMEM;
1087
1088         phy_ring_tail = eth->phy_scratch_ring + soc->txrx.txd_size * (cnt - 1);
1089
1090         for (i = 0; i < cnt; i++) {
1091                 struct mtk_tx_dma_v2 *txd;
1092
1093                 txd = eth->scratch_ring + i * soc->txrx.txd_size;
1094                 txd->txd1 = dma_addr + i * MTK_QDMA_PAGE_SIZE;
1095                 if (i < cnt - 1)
1096                         txd->txd2 = eth->phy_scratch_ring +
1097                                     (i + 1) * soc->txrx.txd_size;
1098
1099                 txd->txd3 = TX_DMA_PLEN0(MTK_QDMA_PAGE_SIZE);
1100                 txd->txd4 = 0;
1101                 if (MTK_HAS_CAPS(soc->caps, MTK_NETSYS_V2)) {
1102                         txd->txd5 = 0;
1103                         txd->txd6 = 0;
1104                         txd->txd7 = 0;
1105                         txd->txd8 = 0;
1106                 }
1107         }
1108
1109         mtk_w32(eth, eth->phy_scratch_ring, soc->reg_map->qdma.fq_head);
1110         mtk_w32(eth, phy_ring_tail, soc->reg_map->qdma.fq_tail);
1111         mtk_w32(eth, (cnt << 16) | cnt, soc->reg_map->qdma.fq_count);
1112         mtk_w32(eth, MTK_QDMA_PAGE_SIZE << 16, soc->reg_map->qdma.fq_blen);
1113
1114         return 0;
1115 }
1116
1117 static void *mtk_qdma_phys_to_virt(struct mtk_tx_ring *ring, u32 desc)
1118 {
1119         return ring->dma + (desc - ring->phys);
1120 }
1121
1122 static struct mtk_tx_buf *mtk_desc_to_tx_buf(struct mtk_tx_ring *ring,
1123                                              void *txd, u32 txd_size)
1124 {
1125         int idx = (txd - ring->dma) / txd_size;
1126
1127         return &ring->buf[idx];
1128 }
1129
1130 static struct mtk_tx_dma *qdma_to_pdma(struct mtk_tx_ring *ring,
1131                                        struct mtk_tx_dma *dma)
1132 {
1133         return ring->dma_pdma - (struct mtk_tx_dma *)ring->dma + dma;
1134 }
1135
1136 static int txd_to_idx(struct mtk_tx_ring *ring, void *dma, u32 txd_size)
1137 {
1138         return (dma - ring->dma) / txd_size;
1139 }
1140
1141 static void mtk_tx_unmap(struct mtk_eth *eth, struct mtk_tx_buf *tx_buf,
1142                          struct xdp_frame_bulk *bq, bool napi)
1143 {
1144         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
1145                 if (tx_buf->flags & MTK_TX_FLAGS_SINGLE0) {
1146                         dma_unmap_single(eth->dma_dev,
1147                                          dma_unmap_addr(tx_buf, dma_addr0),
1148                                          dma_unmap_len(tx_buf, dma_len0),
1149                                          DMA_TO_DEVICE);
1150                 } else if (tx_buf->flags & MTK_TX_FLAGS_PAGE0) {
1151                         dma_unmap_page(eth->dma_dev,
1152                                        dma_unmap_addr(tx_buf, dma_addr0),
1153                                        dma_unmap_len(tx_buf, dma_len0),
1154                                        DMA_TO_DEVICE);
1155                 }
1156         } else {
1157                 if (dma_unmap_len(tx_buf, dma_len0)) {
1158                         dma_unmap_page(eth->dma_dev,
1159                                        dma_unmap_addr(tx_buf, dma_addr0),
1160                                        dma_unmap_len(tx_buf, dma_len0),
1161                                        DMA_TO_DEVICE);
1162                 }
1163
1164                 if (dma_unmap_len(tx_buf, dma_len1)) {
1165                         dma_unmap_page(eth->dma_dev,
1166                                        dma_unmap_addr(tx_buf, dma_addr1),
1167                                        dma_unmap_len(tx_buf, dma_len1),
1168                                        DMA_TO_DEVICE);
1169                 }
1170         }
1171
1172         if (tx_buf->data && tx_buf->data != (void *)MTK_DMA_DUMMY_DESC) {
1173                 if (tx_buf->type == MTK_TYPE_SKB) {
1174                         struct sk_buff *skb = tx_buf->data;
1175
1176                         if (napi)
1177                                 napi_consume_skb(skb, napi);
1178                         else
1179                                 dev_kfree_skb_any(skb);
1180                 } else {
1181                         struct xdp_frame *xdpf = tx_buf->data;
1182
1183                         if (napi && tx_buf->type == MTK_TYPE_XDP_TX)
1184                                 xdp_return_frame_rx_napi(xdpf);
1185                         else if (bq)
1186                                 xdp_return_frame_bulk(xdpf, bq);
1187                         else
1188                                 xdp_return_frame(xdpf);
1189                 }
1190         }
1191         tx_buf->flags = 0;
1192         tx_buf->data = NULL;
1193 }
1194
1195 static void setup_tx_buf(struct mtk_eth *eth, struct mtk_tx_buf *tx_buf,
1196                          struct mtk_tx_dma *txd, dma_addr_t mapped_addr,
1197                          size_t size, int idx)
1198 {
1199         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
1200                 dma_unmap_addr_set(tx_buf, dma_addr0, mapped_addr);
1201                 dma_unmap_len_set(tx_buf, dma_len0, size);
1202         } else {
1203                 if (idx & 1) {
1204                         txd->txd3 = mapped_addr;
1205                         txd->txd2 |= TX_DMA_PLEN1(size);
1206                         dma_unmap_addr_set(tx_buf, dma_addr1, mapped_addr);
1207                         dma_unmap_len_set(tx_buf, dma_len1, size);
1208                 } else {
1209                         tx_buf->data = (void *)MTK_DMA_DUMMY_DESC;
1210                         txd->txd1 = mapped_addr;
1211                         txd->txd2 = TX_DMA_PLEN0(size);
1212                         dma_unmap_addr_set(tx_buf, dma_addr0, mapped_addr);
1213                         dma_unmap_len_set(tx_buf, dma_len0, size);
1214                 }
1215         }
1216 }
1217
1218 static void mtk_tx_set_dma_desc_v1(struct net_device *dev, void *txd,
1219                                    struct mtk_tx_dma_desc_info *info)
1220 {
1221         struct mtk_mac *mac = netdev_priv(dev);
1222         struct mtk_eth *eth = mac->hw;
1223         struct mtk_tx_dma *desc = txd;
1224         u32 data;
1225
1226         WRITE_ONCE(desc->txd1, info->addr);
1227
1228         data = TX_DMA_SWC | TX_DMA_PLEN0(info->size) |
1229                FIELD_PREP(TX_DMA_PQID, info->qid);
1230         if (info->last)
1231                 data |= TX_DMA_LS0;
1232         WRITE_ONCE(desc->txd3, data);
1233
1234         data = (mac->id + 1) << TX_DMA_FPORT_SHIFT; /* forward port */
1235         if (info->first) {
1236                 if (info->gso)
1237                         data |= TX_DMA_TSO;
1238                 /* tx checksum offload */
1239                 if (info->csum)
1240                         data |= TX_DMA_CHKSUM;
1241                 /* vlan header offload */
1242                 if (info->vlan)
1243                         data |= TX_DMA_INS_VLAN | info->vlan_tci;
1244         }
1245         WRITE_ONCE(desc->txd4, data);
1246 }
1247
1248 static void mtk_tx_set_dma_desc_v2(struct net_device *dev, void *txd,
1249                                    struct mtk_tx_dma_desc_info *info)
1250 {
1251         struct mtk_mac *mac = netdev_priv(dev);
1252         struct mtk_tx_dma_v2 *desc = txd;
1253         struct mtk_eth *eth = mac->hw;
1254         u32 data;
1255
1256         WRITE_ONCE(desc->txd1, info->addr);
1257
1258         data = TX_DMA_PLEN0(info->size);
1259         if (info->last)
1260                 data |= TX_DMA_LS0;
1261         WRITE_ONCE(desc->txd3, data);
1262
1263         data = (mac->id + 1) << TX_DMA_FPORT_SHIFT_V2; /* forward port */
1264         data |= TX_DMA_SWC_V2 | QID_BITS_V2(info->qid);
1265         WRITE_ONCE(desc->txd4, data);
1266
1267         data = 0;
1268         if (info->first) {
1269                 if (info->gso)
1270                         data |= TX_DMA_TSO_V2;
1271                 /* tx checksum offload */
1272                 if (info->csum)
1273                         data |= TX_DMA_CHKSUM_V2;
1274         }
1275         WRITE_ONCE(desc->txd5, data);
1276
1277         data = 0;
1278         if (info->first && info->vlan)
1279                 data |= TX_DMA_INS_VLAN_V2 | info->vlan_tci;
1280         WRITE_ONCE(desc->txd6, data);
1281
1282         WRITE_ONCE(desc->txd7, 0);
1283         WRITE_ONCE(desc->txd8, 0);
1284 }
1285
1286 static void mtk_tx_set_dma_desc(struct net_device *dev, void *txd,
1287                                 struct mtk_tx_dma_desc_info *info)
1288 {
1289         struct mtk_mac *mac = netdev_priv(dev);
1290         struct mtk_eth *eth = mac->hw;
1291
1292         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
1293                 mtk_tx_set_dma_desc_v2(dev, txd, info);
1294         else
1295                 mtk_tx_set_dma_desc_v1(dev, txd, info);
1296 }
1297
1298 static int mtk_tx_map(struct sk_buff *skb, struct net_device *dev,
1299                       int tx_num, struct mtk_tx_ring *ring, bool gso)
1300 {
1301         struct mtk_tx_dma_desc_info txd_info = {
1302                 .size = skb_headlen(skb),
1303                 .gso = gso,
1304                 .csum = skb->ip_summed == CHECKSUM_PARTIAL,
1305                 .vlan = skb_vlan_tag_present(skb),
1306                 .qid = skb_get_queue_mapping(skb),
1307                 .vlan_tci = skb_vlan_tag_get(skb),
1308                 .first = true,
1309                 .last = !skb_is_nonlinear(skb),
1310         };
1311         struct netdev_queue *txq;
1312         struct mtk_mac *mac = netdev_priv(dev);
1313         struct mtk_eth *eth = mac->hw;
1314         const struct mtk_soc_data *soc = eth->soc;
1315         struct mtk_tx_dma *itxd, *txd;
1316         struct mtk_tx_dma *itxd_pdma, *txd_pdma;
1317         struct mtk_tx_buf *itx_buf, *tx_buf;
1318         int i, n_desc = 1;
1319         int queue = skb_get_queue_mapping(skb);
1320         int k = 0;
1321
1322         txq = netdev_get_tx_queue(dev, queue);
1323         itxd = ring->next_free;
1324         itxd_pdma = qdma_to_pdma(ring, itxd);
1325         if (itxd == ring->last_free)
1326                 return -ENOMEM;
1327
1328         itx_buf = mtk_desc_to_tx_buf(ring, itxd, soc->txrx.txd_size);
1329         memset(itx_buf, 0, sizeof(*itx_buf));
1330
1331         txd_info.addr = dma_map_single(eth->dma_dev, skb->data, txd_info.size,
1332                                        DMA_TO_DEVICE);
1333         if (unlikely(dma_mapping_error(eth->dma_dev, txd_info.addr)))
1334                 return -ENOMEM;
1335
1336         mtk_tx_set_dma_desc(dev, itxd, &txd_info);
1337
1338         itx_buf->flags |= MTK_TX_FLAGS_SINGLE0;
1339         itx_buf->flags |= (!mac->id) ? MTK_TX_FLAGS_FPORT0 :
1340                           MTK_TX_FLAGS_FPORT1;
1341         setup_tx_buf(eth, itx_buf, itxd_pdma, txd_info.addr, txd_info.size,
1342                      k++);
1343
1344         /* TX SG offload */
1345         txd = itxd;
1346         txd_pdma = qdma_to_pdma(ring, txd);
1347
1348         for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1349                 skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
1350                 unsigned int offset = 0;
1351                 int frag_size = skb_frag_size(frag);
1352
1353                 while (frag_size) {
1354                         bool new_desc = true;
1355
1356                         if (MTK_HAS_CAPS(soc->caps, MTK_QDMA) ||
1357                             (i & 0x1)) {
1358                                 txd = mtk_qdma_phys_to_virt(ring, txd->txd2);
1359                                 txd_pdma = qdma_to_pdma(ring, txd);
1360                                 if (txd == ring->last_free)
1361                                         goto err_dma;
1362
1363                                 n_desc++;
1364                         } else {
1365                                 new_desc = false;
1366                         }
1367
1368                         memset(&txd_info, 0, sizeof(struct mtk_tx_dma_desc_info));
1369                         txd_info.size = min_t(unsigned int, frag_size,
1370                                               soc->txrx.dma_max_len);
1371                         txd_info.qid = queue;
1372                         txd_info.last = i == skb_shinfo(skb)->nr_frags - 1 &&
1373                                         !(frag_size - txd_info.size);
1374                         txd_info.addr = skb_frag_dma_map(eth->dma_dev, frag,
1375                                                          offset, txd_info.size,
1376                                                          DMA_TO_DEVICE);
1377                         if (unlikely(dma_mapping_error(eth->dma_dev, txd_info.addr)))
1378                                 goto err_dma;
1379
1380                         mtk_tx_set_dma_desc(dev, txd, &txd_info);
1381
1382                         tx_buf = mtk_desc_to_tx_buf(ring, txd,
1383                                                     soc->txrx.txd_size);
1384                         if (new_desc)
1385                                 memset(tx_buf, 0, sizeof(*tx_buf));
1386                         tx_buf->data = (void *)MTK_DMA_DUMMY_DESC;
1387                         tx_buf->flags |= MTK_TX_FLAGS_PAGE0;
1388                         tx_buf->flags |= (!mac->id) ? MTK_TX_FLAGS_FPORT0 :
1389                                          MTK_TX_FLAGS_FPORT1;
1390
1391                         setup_tx_buf(eth, tx_buf, txd_pdma, txd_info.addr,
1392                                      txd_info.size, k++);
1393
1394                         frag_size -= txd_info.size;
1395                         offset += txd_info.size;
1396                 }
1397         }
1398
1399         /* store skb to cleanup */
1400         itx_buf->type = MTK_TYPE_SKB;
1401         itx_buf->data = skb;
1402
1403         if (!MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
1404                 if (k & 0x1)
1405                         txd_pdma->txd2 |= TX_DMA_LS0;
1406                 else
1407                         txd_pdma->txd2 |= TX_DMA_LS1;
1408         }
1409
1410         netdev_tx_sent_queue(txq, skb->len);
1411         skb_tx_timestamp(skb);
1412
1413         ring->next_free = mtk_qdma_phys_to_virt(ring, txd->txd2);
1414         atomic_sub(n_desc, &ring->free_count);
1415
1416         /* make sure that all changes to the dma ring are flushed before we
1417          * continue
1418          */
1419         wmb();
1420
1421         if (MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
1422                 if (netif_xmit_stopped(txq) || !netdev_xmit_more())
1423                         mtk_w32(eth, txd->txd2, soc->reg_map->qdma.ctx_ptr);
1424         } else {
1425                 int next_idx;
1426
1427                 next_idx = NEXT_DESP_IDX(txd_to_idx(ring, txd, soc->txrx.txd_size),
1428                                          ring->dma_size);
1429                 mtk_w32(eth, next_idx, MT7628_TX_CTX_IDX0);
1430         }
1431
1432         return 0;
1433
1434 err_dma:
1435         do {
1436                 tx_buf = mtk_desc_to_tx_buf(ring, itxd, soc->txrx.txd_size);
1437
1438                 /* unmap dma */
1439                 mtk_tx_unmap(eth, tx_buf, NULL, false);
1440
1441                 itxd->txd3 = TX_DMA_LS0 | TX_DMA_OWNER_CPU;
1442                 if (!MTK_HAS_CAPS(soc->caps, MTK_QDMA))
1443                         itxd_pdma->txd2 = TX_DMA_DESP2_DEF;
1444
1445                 itxd = mtk_qdma_phys_to_virt(ring, itxd->txd2);
1446                 itxd_pdma = qdma_to_pdma(ring, itxd);
1447         } while (itxd != txd);
1448
1449         return -ENOMEM;
1450 }
1451
1452 static int mtk_cal_txd_req(struct mtk_eth *eth, struct sk_buff *skb)
1453 {
1454         int i, nfrags = 1;
1455         skb_frag_t *frag;
1456
1457         if (skb_is_gso(skb)) {
1458                 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
1459                         frag = &skb_shinfo(skb)->frags[i];
1460                         nfrags += DIV_ROUND_UP(skb_frag_size(frag),
1461                                                eth->soc->txrx.dma_max_len);
1462                 }
1463         } else {
1464                 nfrags += skb_shinfo(skb)->nr_frags;
1465         }
1466
1467         return nfrags;
1468 }
1469
1470 static int mtk_queue_stopped(struct mtk_eth *eth)
1471 {
1472         int i;
1473
1474         for (i = 0; i < MTK_MAC_COUNT; i++) {
1475                 if (!eth->netdev[i])
1476                         continue;
1477                 if (netif_queue_stopped(eth->netdev[i]))
1478                         return 1;
1479         }
1480
1481         return 0;
1482 }
1483
1484 static void mtk_wake_queue(struct mtk_eth *eth)
1485 {
1486         int i;
1487
1488         for (i = 0; i < MTK_MAC_COUNT; i++) {
1489                 if (!eth->netdev[i])
1490                         continue;
1491                 netif_tx_wake_all_queues(eth->netdev[i]);
1492         }
1493 }
1494
1495 static netdev_tx_t mtk_start_xmit(struct sk_buff *skb, struct net_device *dev)
1496 {
1497         struct mtk_mac *mac = netdev_priv(dev);
1498         struct mtk_eth *eth = mac->hw;
1499         struct mtk_tx_ring *ring = &eth->tx_ring;
1500         struct net_device_stats *stats = &dev->stats;
1501         bool gso = false;
1502         int tx_num;
1503
1504         /* normally we can rely on the stack not calling this more than once,
1505          * however we have 2 queues running on the same ring so we need to lock
1506          * the ring access
1507          */
1508         spin_lock(&eth->page_lock);
1509
1510         if (unlikely(test_bit(MTK_RESETTING, &eth->state)))
1511                 goto drop;
1512
1513         tx_num = mtk_cal_txd_req(eth, skb);
1514         if (unlikely(atomic_read(&ring->free_count) <= tx_num)) {
1515                 netif_tx_stop_all_queues(dev);
1516                 netif_err(eth, tx_queued, dev,
1517                           "Tx Ring full when queue awake!\n");
1518                 spin_unlock(&eth->page_lock);
1519                 return NETDEV_TX_BUSY;
1520         }
1521
1522         /* TSO: fill MSS info in tcp checksum field */
1523         if (skb_is_gso(skb)) {
1524                 if (skb_cow_head(skb, 0)) {
1525                         netif_warn(eth, tx_err, dev,
1526                                    "GSO expand head fail.\n");
1527                         goto drop;
1528                 }
1529
1530                 if (skb_shinfo(skb)->gso_type &
1531                                 (SKB_GSO_TCPV4 | SKB_GSO_TCPV6)) {
1532                         gso = true;
1533                         tcp_hdr(skb)->check = htons(skb_shinfo(skb)->gso_size);
1534                 }
1535         }
1536
1537         if (mtk_tx_map(skb, dev, tx_num, ring, gso) < 0)
1538                 goto drop;
1539
1540         if (unlikely(atomic_read(&ring->free_count) <= ring->thresh))
1541                 netif_tx_stop_all_queues(dev);
1542
1543         spin_unlock(&eth->page_lock);
1544
1545         return NETDEV_TX_OK;
1546
1547 drop:
1548         spin_unlock(&eth->page_lock);
1549         stats->tx_dropped++;
1550         dev_kfree_skb_any(skb);
1551         return NETDEV_TX_OK;
1552 }
1553
1554 static struct mtk_rx_ring *mtk_get_rx_ring(struct mtk_eth *eth)
1555 {
1556         int i;
1557         struct mtk_rx_ring *ring;
1558         int idx;
1559
1560         if (!eth->hwlro)
1561                 return &eth->rx_ring[0];
1562
1563         for (i = 0; i < MTK_MAX_RX_RING_NUM; i++) {
1564                 struct mtk_rx_dma *rxd;
1565
1566                 ring = &eth->rx_ring[i];
1567                 idx = NEXT_DESP_IDX(ring->calc_idx, ring->dma_size);
1568                 rxd = ring->dma + idx * eth->soc->txrx.rxd_size;
1569                 if (rxd->rxd2 & RX_DMA_DONE) {
1570                         ring->calc_idx_update = true;
1571                         return ring;
1572                 }
1573         }
1574
1575         return NULL;
1576 }
1577
1578 static void mtk_update_rx_cpu_idx(struct mtk_eth *eth)
1579 {
1580         struct mtk_rx_ring *ring;
1581         int i;
1582
1583         if (!eth->hwlro) {
1584                 ring = &eth->rx_ring[0];
1585                 mtk_w32(eth, ring->calc_idx, ring->crx_idx_reg);
1586         } else {
1587                 for (i = 0; i < MTK_MAX_RX_RING_NUM; i++) {
1588                         ring = &eth->rx_ring[i];
1589                         if (ring->calc_idx_update) {
1590                                 ring->calc_idx_update = false;
1591                                 mtk_w32(eth, ring->calc_idx, ring->crx_idx_reg);
1592                         }
1593                 }
1594         }
1595 }
1596
1597 static bool mtk_page_pool_enabled(struct mtk_eth *eth)
1598 {
1599         return MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2);
1600 }
1601
1602 static struct page_pool *mtk_create_page_pool(struct mtk_eth *eth,
1603                                               struct xdp_rxq_info *xdp_q,
1604                                               int id, int size)
1605 {
1606         struct page_pool_params pp_params = {
1607                 .order = 0,
1608                 .flags = PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV,
1609                 .pool_size = size,
1610                 .nid = NUMA_NO_NODE,
1611                 .dev = eth->dma_dev,
1612                 .offset = MTK_PP_HEADROOM,
1613                 .max_len = MTK_PP_MAX_BUF_SIZE,
1614         };
1615         struct page_pool *pp;
1616         int err;
1617
1618         pp_params.dma_dir = rcu_access_pointer(eth->prog) ? DMA_BIDIRECTIONAL
1619                                                           : DMA_FROM_DEVICE;
1620         pp = page_pool_create(&pp_params);
1621         if (IS_ERR(pp))
1622                 return pp;
1623
1624         err = __xdp_rxq_info_reg(xdp_q, &eth->dummy_dev, id,
1625                                  eth->rx_napi.napi_id, PAGE_SIZE);
1626         if (err < 0)
1627                 goto err_free_pp;
1628
1629         err = xdp_rxq_info_reg_mem_model(xdp_q, MEM_TYPE_PAGE_POOL, pp);
1630         if (err)
1631                 goto err_unregister_rxq;
1632
1633         return pp;
1634
1635 err_unregister_rxq:
1636         xdp_rxq_info_unreg(xdp_q);
1637 err_free_pp:
1638         page_pool_destroy(pp);
1639
1640         return ERR_PTR(err);
1641 }
1642
1643 static void *mtk_page_pool_get_buff(struct page_pool *pp, dma_addr_t *dma_addr,
1644                                     gfp_t gfp_mask)
1645 {
1646         struct page *page;
1647
1648         page = page_pool_alloc_pages(pp, gfp_mask | __GFP_NOWARN);
1649         if (!page)
1650                 return NULL;
1651
1652         *dma_addr = page_pool_get_dma_addr(page) + MTK_PP_HEADROOM;
1653         return page_address(page);
1654 }
1655
1656 static void mtk_rx_put_buff(struct mtk_rx_ring *ring, void *data, bool napi)
1657 {
1658         if (ring->page_pool)
1659                 page_pool_put_full_page(ring->page_pool,
1660                                         virt_to_head_page(data), napi);
1661         else
1662                 skb_free_frag(data);
1663 }
1664
1665 static int mtk_xdp_frame_map(struct mtk_eth *eth, struct net_device *dev,
1666                              struct mtk_tx_dma_desc_info *txd_info,
1667                              struct mtk_tx_dma *txd, struct mtk_tx_buf *tx_buf,
1668                              void *data, u16 headroom, int index, bool dma_map)
1669 {
1670         struct mtk_tx_ring *ring = &eth->tx_ring;
1671         struct mtk_mac *mac = netdev_priv(dev);
1672         struct mtk_tx_dma *txd_pdma;
1673
1674         if (dma_map) {  /* ndo_xdp_xmit */
1675                 txd_info->addr = dma_map_single(eth->dma_dev, data,
1676                                                 txd_info->size, DMA_TO_DEVICE);
1677                 if (unlikely(dma_mapping_error(eth->dma_dev, txd_info->addr)))
1678                         return -ENOMEM;
1679
1680                 tx_buf->flags |= MTK_TX_FLAGS_SINGLE0;
1681         } else {
1682                 struct page *page = virt_to_head_page(data);
1683
1684                 txd_info->addr = page_pool_get_dma_addr(page) +
1685                                  sizeof(struct xdp_frame) + headroom;
1686                 dma_sync_single_for_device(eth->dma_dev, txd_info->addr,
1687                                            txd_info->size, DMA_BIDIRECTIONAL);
1688         }
1689         mtk_tx_set_dma_desc(dev, txd, txd_info);
1690
1691         tx_buf->flags |= !mac->id ? MTK_TX_FLAGS_FPORT0 : MTK_TX_FLAGS_FPORT1;
1692         tx_buf->type = dma_map ? MTK_TYPE_XDP_NDO : MTK_TYPE_XDP_TX;
1693         tx_buf->data = (void *)MTK_DMA_DUMMY_DESC;
1694
1695         txd_pdma = qdma_to_pdma(ring, txd);
1696         setup_tx_buf(eth, tx_buf, txd_pdma, txd_info->addr, txd_info->size,
1697                      index);
1698
1699         return 0;
1700 }
1701
1702 static int mtk_xdp_submit_frame(struct mtk_eth *eth, struct xdp_frame *xdpf,
1703                                 struct net_device *dev, bool dma_map)
1704 {
1705         struct skb_shared_info *sinfo = xdp_get_shared_info_from_frame(xdpf);
1706         const struct mtk_soc_data *soc = eth->soc;
1707         struct mtk_tx_ring *ring = &eth->tx_ring;
1708         struct mtk_mac *mac = netdev_priv(dev);
1709         struct mtk_tx_dma_desc_info txd_info = {
1710                 .size   = xdpf->len,
1711                 .first  = true,
1712                 .last   = !xdp_frame_has_frags(xdpf),
1713                 .qid    = mac->id,
1714         };
1715         int err, index = 0, n_desc = 1, nr_frags;
1716         struct mtk_tx_buf *htx_buf, *tx_buf;
1717         struct mtk_tx_dma *htxd, *txd;
1718         void *data = xdpf->data;
1719
1720         if (unlikely(test_bit(MTK_RESETTING, &eth->state)))
1721                 return -EBUSY;
1722
1723         nr_frags = unlikely(xdp_frame_has_frags(xdpf)) ? sinfo->nr_frags : 0;
1724         if (unlikely(atomic_read(&ring->free_count) <= 1 + nr_frags))
1725                 return -EBUSY;
1726
1727         spin_lock(&eth->page_lock);
1728
1729         txd = ring->next_free;
1730         if (txd == ring->last_free) {
1731                 spin_unlock(&eth->page_lock);
1732                 return -ENOMEM;
1733         }
1734         htxd = txd;
1735
1736         tx_buf = mtk_desc_to_tx_buf(ring, txd, soc->txrx.txd_size);
1737         memset(tx_buf, 0, sizeof(*tx_buf));
1738         htx_buf = tx_buf;
1739
1740         for (;;) {
1741                 err = mtk_xdp_frame_map(eth, dev, &txd_info, txd, tx_buf,
1742                                         data, xdpf->headroom, index, dma_map);
1743                 if (err < 0)
1744                         goto unmap;
1745
1746                 if (txd_info.last)
1747                         break;
1748
1749                 if (MTK_HAS_CAPS(soc->caps, MTK_QDMA) || (index & 0x1)) {
1750                         txd = mtk_qdma_phys_to_virt(ring, txd->txd2);
1751                         if (txd == ring->last_free)
1752                                 goto unmap;
1753
1754                         tx_buf = mtk_desc_to_tx_buf(ring, txd,
1755                                                     soc->txrx.txd_size);
1756                         memset(tx_buf, 0, sizeof(*tx_buf));
1757                         n_desc++;
1758                 }
1759
1760                 memset(&txd_info, 0, sizeof(struct mtk_tx_dma_desc_info));
1761                 txd_info.size = skb_frag_size(&sinfo->frags[index]);
1762                 txd_info.last = index + 1 == nr_frags;
1763                 txd_info.qid = mac->id;
1764                 data = skb_frag_address(&sinfo->frags[index]);
1765
1766                 index++;
1767         }
1768         /* store xdpf for cleanup */
1769         htx_buf->data = xdpf;
1770
1771         if (!MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
1772                 struct mtk_tx_dma *txd_pdma = qdma_to_pdma(ring, txd);
1773
1774                 if (index & 1)
1775                         txd_pdma->txd2 |= TX_DMA_LS0;
1776                 else
1777                         txd_pdma->txd2 |= TX_DMA_LS1;
1778         }
1779
1780         ring->next_free = mtk_qdma_phys_to_virt(ring, txd->txd2);
1781         atomic_sub(n_desc, &ring->free_count);
1782
1783         /* make sure that all changes to the dma ring are flushed before we
1784          * continue
1785          */
1786         wmb();
1787
1788         if (MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
1789                 mtk_w32(eth, txd->txd2, soc->reg_map->qdma.ctx_ptr);
1790         } else {
1791                 int idx;
1792
1793                 idx = txd_to_idx(ring, txd, soc->txrx.txd_size);
1794                 mtk_w32(eth, NEXT_DESP_IDX(idx, ring->dma_size),
1795                         MT7628_TX_CTX_IDX0);
1796         }
1797
1798         spin_unlock(&eth->page_lock);
1799
1800         return 0;
1801
1802 unmap:
1803         while (htxd != txd) {
1804                 tx_buf = mtk_desc_to_tx_buf(ring, htxd, soc->txrx.txd_size);
1805                 mtk_tx_unmap(eth, tx_buf, NULL, false);
1806
1807                 htxd->txd3 = TX_DMA_LS0 | TX_DMA_OWNER_CPU;
1808                 if (!MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
1809                         struct mtk_tx_dma *txd_pdma = qdma_to_pdma(ring, htxd);
1810
1811                         txd_pdma->txd2 = TX_DMA_DESP2_DEF;
1812                 }
1813
1814                 htxd = mtk_qdma_phys_to_virt(ring, htxd->txd2);
1815         }
1816
1817         spin_unlock(&eth->page_lock);
1818
1819         return err;
1820 }
1821
1822 static int mtk_xdp_xmit(struct net_device *dev, int num_frame,
1823                         struct xdp_frame **frames, u32 flags)
1824 {
1825         struct mtk_mac *mac = netdev_priv(dev);
1826         struct mtk_hw_stats *hw_stats = mac->hw_stats;
1827         struct mtk_eth *eth = mac->hw;
1828         int i, nxmit = 0;
1829
1830         if (unlikely(flags & ~XDP_XMIT_FLAGS_MASK))
1831                 return -EINVAL;
1832
1833         for (i = 0; i < num_frame; i++) {
1834                 if (mtk_xdp_submit_frame(eth, frames[i], dev, true))
1835                         break;
1836                 nxmit++;
1837         }
1838
1839         u64_stats_update_begin(&hw_stats->syncp);
1840         hw_stats->xdp_stats.tx_xdp_xmit += nxmit;
1841         hw_stats->xdp_stats.tx_xdp_xmit_errors += num_frame - nxmit;
1842         u64_stats_update_end(&hw_stats->syncp);
1843
1844         return nxmit;
1845 }
1846
1847 static u32 mtk_xdp_run(struct mtk_eth *eth, struct mtk_rx_ring *ring,
1848                        struct xdp_buff *xdp, struct net_device *dev)
1849 {
1850         struct mtk_mac *mac = netdev_priv(dev);
1851         struct mtk_hw_stats *hw_stats = mac->hw_stats;
1852         u64 *count = &hw_stats->xdp_stats.rx_xdp_drop;
1853         struct bpf_prog *prog;
1854         u32 act = XDP_PASS;
1855
1856         rcu_read_lock();
1857
1858         prog = rcu_dereference(eth->prog);
1859         if (!prog)
1860                 goto out;
1861
1862         act = bpf_prog_run_xdp(prog, xdp);
1863         switch (act) {
1864         case XDP_PASS:
1865                 count = &hw_stats->xdp_stats.rx_xdp_pass;
1866                 goto update_stats;
1867         case XDP_REDIRECT:
1868                 if (unlikely(xdp_do_redirect(dev, xdp, prog))) {
1869                         act = XDP_DROP;
1870                         break;
1871                 }
1872
1873                 count = &hw_stats->xdp_stats.rx_xdp_redirect;
1874                 goto update_stats;
1875         case XDP_TX: {
1876                 struct xdp_frame *xdpf = xdp_convert_buff_to_frame(xdp);
1877
1878                 if (!xdpf || mtk_xdp_submit_frame(eth, xdpf, dev, false)) {
1879                         count = &hw_stats->xdp_stats.rx_xdp_tx_errors;
1880                         act = XDP_DROP;
1881                         break;
1882                 }
1883
1884                 count = &hw_stats->xdp_stats.rx_xdp_tx;
1885                 goto update_stats;
1886         }
1887         default:
1888                 bpf_warn_invalid_xdp_action(dev, prog, act);
1889                 fallthrough;
1890         case XDP_ABORTED:
1891                 trace_xdp_exception(dev, prog, act);
1892                 fallthrough;
1893         case XDP_DROP:
1894                 break;
1895         }
1896
1897         page_pool_put_full_page(ring->page_pool,
1898                                 virt_to_head_page(xdp->data), true);
1899
1900 update_stats:
1901         u64_stats_update_begin(&hw_stats->syncp);
1902         *count = *count + 1;
1903         u64_stats_update_end(&hw_stats->syncp);
1904 out:
1905         rcu_read_unlock();
1906
1907         return act;
1908 }
1909
1910 static int mtk_poll_rx(struct napi_struct *napi, int budget,
1911                        struct mtk_eth *eth)
1912 {
1913         struct dim_sample dim_sample = {};
1914         struct mtk_rx_ring *ring;
1915         bool xdp_flush = false;
1916         int idx;
1917         struct sk_buff *skb;
1918         u8 *data, *new_data;
1919         struct mtk_rx_dma_v2 *rxd, trxd;
1920         int done = 0, bytes = 0;
1921
1922         while (done < budget) {
1923                 unsigned int pktlen, *rxdcsum;
1924                 struct net_device *netdev;
1925                 dma_addr_t dma_addr;
1926                 u32 hash, reason;
1927                 int mac = 0;
1928
1929                 ring = mtk_get_rx_ring(eth);
1930                 if (unlikely(!ring))
1931                         goto rx_done;
1932
1933                 idx = NEXT_DESP_IDX(ring->calc_idx, ring->dma_size);
1934                 rxd = ring->dma + idx * eth->soc->txrx.rxd_size;
1935                 data = ring->data[idx];
1936
1937                 if (!mtk_rx_get_desc(eth, &trxd, rxd))
1938                         break;
1939
1940                 /* find out which mac the packet come from. values start at 1 */
1941                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
1942                         mac = RX_DMA_GET_SPORT_V2(trxd.rxd5) - 1;
1943                 else if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628) &&
1944                          !(trxd.rxd4 & RX_DMA_SPECIAL_TAG))
1945                         mac = RX_DMA_GET_SPORT(trxd.rxd4) - 1;
1946
1947                 if (unlikely(mac < 0 || mac >= MTK_MAC_COUNT ||
1948                              !eth->netdev[mac]))
1949                         goto release_desc;
1950
1951                 netdev = eth->netdev[mac];
1952
1953                 if (unlikely(test_bit(MTK_RESETTING, &eth->state)))
1954                         goto release_desc;
1955
1956                 pktlen = RX_DMA_GET_PLEN0(trxd.rxd2);
1957
1958                 /* alloc new buffer */
1959                 if (ring->page_pool) {
1960                         struct page *page = virt_to_head_page(data);
1961                         struct xdp_buff xdp;
1962                         u32 ret;
1963
1964                         new_data = mtk_page_pool_get_buff(ring->page_pool,
1965                                                           &dma_addr,
1966                                                           GFP_ATOMIC);
1967                         if (unlikely(!new_data)) {
1968                                 netdev->stats.rx_dropped++;
1969                                 goto release_desc;
1970                         }
1971
1972                         dma_sync_single_for_cpu(eth->dma_dev,
1973                                 page_pool_get_dma_addr(page) + MTK_PP_HEADROOM,
1974                                 pktlen, page_pool_get_dma_dir(ring->page_pool));
1975
1976                         xdp_init_buff(&xdp, PAGE_SIZE, &ring->xdp_q);
1977                         xdp_prepare_buff(&xdp, data, MTK_PP_HEADROOM, pktlen,
1978                                          false);
1979                         xdp_buff_clear_frags_flag(&xdp);
1980
1981                         ret = mtk_xdp_run(eth, ring, &xdp, netdev);
1982                         if (ret == XDP_REDIRECT)
1983                                 xdp_flush = true;
1984
1985                         if (ret != XDP_PASS)
1986                                 goto skip_rx;
1987
1988                         skb = build_skb(data, PAGE_SIZE);
1989                         if (unlikely(!skb)) {
1990                                 page_pool_put_full_page(ring->page_pool,
1991                                                         page, true);
1992                                 netdev->stats.rx_dropped++;
1993                                 goto skip_rx;
1994                         }
1995
1996                         skb_reserve(skb, xdp.data - xdp.data_hard_start);
1997                         skb_put(skb, xdp.data_end - xdp.data);
1998                         skb_mark_for_recycle(skb);
1999                 } else {
2000                         if (ring->frag_size <= PAGE_SIZE)
2001                                 new_data = napi_alloc_frag(ring->frag_size);
2002                         else
2003                                 new_data = mtk_max_lro_buf_alloc(GFP_ATOMIC);
2004
2005                         if (unlikely(!new_data)) {
2006                                 netdev->stats.rx_dropped++;
2007                                 goto release_desc;
2008                         }
2009
2010                         dma_addr = dma_map_single(eth->dma_dev,
2011                                 new_data + NET_SKB_PAD + eth->ip_align,
2012                                 ring->buf_size, DMA_FROM_DEVICE);
2013                         if (unlikely(dma_mapping_error(eth->dma_dev,
2014                                                        dma_addr))) {
2015                                 skb_free_frag(new_data);
2016                                 netdev->stats.rx_dropped++;
2017                                 goto release_desc;
2018                         }
2019
2020                         dma_unmap_single(eth->dma_dev, trxd.rxd1,
2021                                          ring->buf_size, DMA_FROM_DEVICE);
2022
2023                         skb = build_skb(data, ring->frag_size);
2024                         if (unlikely(!skb)) {
2025                                 netdev->stats.rx_dropped++;
2026                                 skb_free_frag(data);
2027                                 goto skip_rx;
2028                         }
2029
2030                         skb_reserve(skb, NET_SKB_PAD + NET_IP_ALIGN);
2031                         skb_put(skb, pktlen);
2032                 }
2033
2034                 skb->dev = netdev;
2035                 bytes += skb->len;
2036
2037                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
2038                         reason = FIELD_GET(MTK_RXD5_PPE_CPU_REASON, trxd.rxd5);
2039                         hash = trxd.rxd5 & MTK_RXD5_FOE_ENTRY;
2040                         if (hash != MTK_RXD5_FOE_ENTRY)
2041                                 skb_set_hash(skb, jhash_1word(hash, 0),
2042                                              PKT_HASH_TYPE_L4);
2043                         rxdcsum = &trxd.rxd3;
2044                 } else {
2045                         reason = FIELD_GET(MTK_RXD4_PPE_CPU_REASON, trxd.rxd4);
2046                         hash = trxd.rxd4 & MTK_RXD4_FOE_ENTRY;
2047                         if (hash != MTK_RXD4_FOE_ENTRY)
2048                                 skb_set_hash(skb, jhash_1word(hash, 0),
2049                                              PKT_HASH_TYPE_L4);
2050                         rxdcsum = &trxd.rxd4;
2051                 }
2052
2053                 if (*rxdcsum & eth->soc->txrx.rx_dma_l4_valid)
2054                         skb->ip_summed = CHECKSUM_UNNECESSARY;
2055                 else
2056                         skb_checksum_none_assert(skb);
2057                 skb->protocol = eth_type_trans(skb, netdev);
2058
2059                 /* When using VLAN untagging in combination with DSA, the
2060                  * hardware treats the MTK special tag as a VLAN and untags it.
2061                  */
2062                 if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2) &&
2063                     (trxd.rxd2 & RX_DMA_VTAG) && netdev_uses_dsa(netdev)) {
2064                         unsigned int port = RX_DMA_VPID(trxd.rxd3) & GENMASK(2, 0);
2065
2066                         if (port < ARRAY_SIZE(eth->dsa_meta) &&
2067                             eth->dsa_meta[port])
2068                                 skb_dst_set_noref(skb, &eth->dsa_meta[port]->dst);
2069                 }
2070
2071                 if (reason == MTK_PPE_CPU_REASON_HIT_UNBIND_RATE_REACHED)
2072                         mtk_ppe_check_skb(eth->ppe[0], skb, hash);
2073
2074                 skb_record_rx_queue(skb, 0);
2075                 napi_gro_receive(napi, skb);
2076
2077 skip_rx:
2078                 ring->data[idx] = new_data;
2079                 rxd->rxd1 = (unsigned int)dma_addr;
2080 release_desc:
2081                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
2082                         rxd->rxd2 = RX_DMA_LSO;
2083                 else
2084                         rxd->rxd2 = RX_DMA_PREP_PLEN0(ring->buf_size);
2085
2086                 ring->calc_idx = idx;
2087                 done++;
2088         }
2089
2090 rx_done:
2091         if (done) {
2092                 /* make sure that all changes to the dma ring are flushed before
2093                  * we continue
2094                  */
2095                 wmb();
2096                 mtk_update_rx_cpu_idx(eth);
2097         }
2098
2099         eth->rx_packets += done;
2100         eth->rx_bytes += bytes;
2101         dim_update_sample(eth->rx_events, eth->rx_packets, eth->rx_bytes,
2102                           &dim_sample);
2103         net_dim(&eth->rx_dim, dim_sample);
2104
2105         if (xdp_flush)
2106                 xdp_do_flush_map();
2107
2108         return done;
2109 }
2110
2111 struct mtk_poll_state {
2112     struct netdev_queue *txq;
2113     unsigned int total;
2114     unsigned int done;
2115     unsigned int bytes;
2116 };
2117
2118 static void
2119 mtk_poll_tx_done(struct mtk_eth *eth, struct mtk_poll_state *state, u8 mac,
2120                  struct sk_buff *skb)
2121 {
2122         struct netdev_queue *txq;
2123         struct net_device *dev;
2124         unsigned int bytes = skb->len;
2125
2126         state->total++;
2127         eth->tx_packets++;
2128         eth->tx_bytes += bytes;
2129
2130         dev = eth->netdev[mac];
2131         if (!dev)
2132                 return;
2133
2134         txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
2135         if (state->txq == txq) {
2136                 state->done++;
2137                 state->bytes += bytes;
2138                 return;
2139         }
2140
2141         if (state->txq)
2142                 netdev_tx_completed_queue(state->txq, state->done, state->bytes);
2143
2144         state->txq = txq;
2145         state->done = 1;
2146         state->bytes = bytes;
2147 }
2148
2149 static int mtk_poll_tx_qdma(struct mtk_eth *eth, int budget,
2150                             struct mtk_poll_state *state)
2151 {
2152         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
2153         struct mtk_tx_ring *ring = &eth->tx_ring;
2154         struct mtk_tx_buf *tx_buf;
2155         struct xdp_frame_bulk bq;
2156         struct mtk_tx_dma *desc;
2157         u32 cpu, dma;
2158
2159         cpu = ring->last_free_ptr;
2160         dma = mtk_r32(eth, reg_map->qdma.drx_ptr);
2161
2162         desc = mtk_qdma_phys_to_virt(ring, cpu);
2163         xdp_frame_bulk_init(&bq);
2164
2165         while ((cpu != dma) && budget) {
2166                 u32 next_cpu = desc->txd2;
2167                 int mac = 0;
2168
2169                 desc = mtk_qdma_phys_to_virt(ring, desc->txd2);
2170                 if ((desc->txd3 & TX_DMA_OWNER_CPU) == 0)
2171                         break;
2172
2173                 tx_buf = mtk_desc_to_tx_buf(ring, desc,
2174                                             eth->soc->txrx.txd_size);
2175                 if (tx_buf->flags & MTK_TX_FLAGS_FPORT1)
2176                         mac = 1;
2177
2178                 if (!tx_buf->data)
2179                         break;
2180
2181                 if (tx_buf->data != (void *)MTK_DMA_DUMMY_DESC) {
2182                         if (tx_buf->type == MTK_TYPE_SKB)
2183                                 mtk_poll_tx_done(eth, state, mac, tx_buf->data);
2184
2185                         budget--;
2186                 }
2187                 mtk_tx_unmap(eth, tx_buf, &bq, true);
2188
2189                 ring->last_free = desc;
2190                 atomic_inc(&ring->free_count);
2191
2192                 cpu = next_cpu;
2193         }
2194         xdp_flush_frame_bulk(&bq);
2195
2196         ring->last_free_ptr = cpu;
2197         mtk_w32(eth, cpu, reg_map->qdma.crx_ptr);
2198
2199         return budget;
2200 }
2201
2202 static int mtk_poll_tx_pdma(struct mtk_eth *eth, int budget,
2203                             struct mtk_poll_state *state)
2204 {
2205         struct mtk_tx_ring *ring = &eth->tx_ring;
2206         struct mtk_tx_buf *tx_buf;
2207         struct xdp_frame_bulk bq;
2208         struct mtk_tx_dma *desc;
2209         u32 cpu, dma;
2210
2211         cpu = ring->cpu_idx;
2212         dma = mtk_r32(eth, MT7628_TX_DTX_IDX0);
2213         xdp_frame_bulk_init(&bq);
2214
2215         while ((cpu != dma) && budget) {
2216                 tx_buf = &ring->buf[cpu];
2217                 if (!tx_buf->data)
2218                         break;
2219
2220                 if (tx_buf->data != (void *)MTK_DMA_DUMMY_DESC) {
2221                         if (tx_buf->type == MTK_TYPE_SKB)
2222                                 mtk_poll_tx_done(eth, state, 0, tx_buf->data);
2223                         budget--;
2224                 }
2225                 mtk_tx_unmap(eth, tx_buf, &bq, true);
2226
2227                 desc = ring->dma + cpu * eth->soc->txrx.txd_size;
2228                 ring->last_free = desc;
2229                 atomic_inc(&ring->free_count);
2230
2231                 cpu = NEXT_DESP_IDX(cpu, ring->dma_size);
2232         }
2233         xdp_flush_frame_bulk(&bq);
2234
2235         ring->cpu_idx = cpu;
2236
2237         return budget;
2238 }
2239
2240 static int mtk_poll_tx(struct mtk_eth *eth, int budget)
2241 {
2242         struct mtk_tx_ring *ring = &eth->tx_ring;
2243         struct dim_sample dim_sample = {};
2244         struct mtk_poll_state state = {};
2245
2246         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
2247                 budget = mtk_poll_tx_qdma(eth, budget, &state);
2248         else
2249                 budget = mtk_poll_tx_pdma(eth, budget, &state);
2250
2251         if (state.txq)
2252                 netdev_tx_completed_queue(state.txq, state.done, state.bytes);
2253
2254         dim_update_sample(eth->tx_events, eth->tx_packets, eth->tx_bytes,
2255                           &dim_sample);
2256         net_dim(&eth->tx_dim, dim_sample);
2257
2258         if (mtk_queue_stopped(eth) &&
2259             (atomic_read(&ring->free_count) > ring->thresh))
2260                 mtk_wake_queue(eth);
2261
2262         return state.total;
2263 }
2264
2265 static void mtk_handle_status_irq(struct mtk_eth *eth)
2266 {
2267         u32 status2 = mtk_r32(eth, MTK_INT_STATUS2);
2268
2269         if (unlikely(status2 & (MTK_GDM1_AF | MTK_GDM2_AF))) {
2270                 mtk_stats_update(eth);
2271                 mtk_w32(eth, (MTK_GDM1_AF | MTK_GDM2_AF),
2272                         MTK_INT_STATUS2);
2273         }
2274 }
2275
2276 static int mtk_napi_tx(struct napi_struct *napi, int budget)
2277 {
2278         struct mtk_eth *eth = container_of(napi, struct mtk_eth, tx_napi);
2279         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
2280         int tx_done = 0;
2281
2282         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
2283                 mtk_handle_status_irq(eth);
2284         mtk_w32(eth, MTK_TX_DONE_INT, reg_map->tx_irq_status);
2285         tx_done = mtk_poll_tx(eth, budget);
2286
2287         if (unlikely(netif_msg_intr(eth))) {
2288                 dev_info(eth->dev,
2289                          "done tx %d, intr 0x%08x/0x%x\n", tx_done,
2290                          mtk_r32(eth, reg_map->tx_irq_status),
2291                          mtk_r32(eth, reg_map->tx_irq_mask));
2292         }
2293
2294         if (tx_done == budget)
2295                 return budget;
2296
2297         if (mtk_r32(eth, reg_map->tx_irq_status) & MTK_TX_DONE_INT)
2298                 return budget;
2299
2300         if (napi_complete_done(napi, tx_done))
2301                 mtk_tx_irq_enable(eth, MTK_TX_DONE_INT);
2302
2303         return tx_done;
2304 }
2305
2306 static int mtk_napi_rx(struct napi_struct *napi, int budget)
2307 {
2308         struct mtk_eth *eth = container_of(napi, struct mtk_eth, rx_napi);
2309         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
2310         int rx_done_total = 0;
2311
2312         mtk_handle_status_irq(eth);
2313
2314         do {
2315                 int rx_done;
2316
2317                 mtk_w32(eth, eth->soc->txrx.rx_irq_done_mask,
2318                         reg_map->pdma.irq_status);
2319                 rx_done = mtk_poll_rx(napi, budget - rx_done_total, eth);
2320                 rx_done_total += rx_done;
2321
2322                 if (unlikely(netif_msg_intr(eth))) {
2323                         dev_info(eth->dev,
2324                                  "done rx %d, intr 0x%08x/0x%x\n", rx_done,
2325                                  mtk_r32(eth, reg_map->pdma.irq_status),
2326                                  mtk_r32(eth, reg_map->pdma.irq_mask));
2327                 }
2328
2329                 if (rx_done_total == budget)
2330                         return budget;
2331
2332         } while (mtk_r32(eth, reg_map->pdma.irq_status) &
2333                  eth->soc->txrx.rx_irq_done_mask);
2334
2335         if (napi_complete_done(napi, rx_done_total))
2336                 mtk_rx_irq_enable(eth, eth->soc->txrx.rx_irq_done_mask);
2337
2338         return rx_done_total;
2339 }
2340
2341 static int mtk_tx_alloc(struct mtk_eth *eth)
2342 {
2343         const struct mtk_soc_data *soc = eth->soc;
2344         struct mtk_tx_ring *ring = &eth->tx_ring;
2345         int i, sz = soc->txrx.txd_size;
2346         struct mtk_tx_dma_v2 *txd;
2347         int ring_size;
2348         u32 ofs, val;
2349
2350         if (MTK_HAS_CAPS(soc->caps, MTK_QDMA))
2351                 ring_size = MTK_QDMA_RING_SIZE;
2352         else
2353                 ring_size = MTK_DMA_SIZE;
2354
2355         ring->buf = kcalloc(ring_size, sizeof(*ring->buf),
2356                                GFP_KERNEL);
2357         if (!ring->buf)
2358                 goto no_tx_mem;
2359
2360         ring->dma = dma_alloc_coherent(eth->dma_dev, ring_size * sz,
2361                                        &ring->phys, GFP_KERNEL);
2362         if (!ring->dma)
2363                 goto no_tx_mem;
2364
2365         for (i = 0; i < ring_size; i++) {
2366                 int next = (i + 1) % ring_size;
2367                 u32 next_ptr = ring->phys + next * sz;
2368
2369                 txd = ring->dma + i * sz;
2370                 txd->txd2 = next_ptr;
2371                 txd->txd3 = TX_DMA_LS0 | TX_DMA_OWNER_CPU;
2372                 txd->txd4 = 0;
2373                 if (MTK_HAS_CAPS(soc->caps, MTK_NETSYS_V2)) {
2374                         txd->txd5 = 0;
2375                         txd->txd6 = 0;
2376                         txd->txd7 = 0;
2377                         txd->txd8 = 0;
2378                 }
2379         }
2380
2381         /* On MT7688 (PDMA only) this driver uses the ring->dma structs
2382          * only as the framework. The real HW descriptors are the PDMA
2383          * descriptors in ring->dma_pdma.
2384          */
2385         if (!MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
2386                 ring->dma_pdma = dma_alloc_coherent(eth->dma_dev, ring_size * sz,
2387                                                     &ring->phys_pdma, GFP_KERNEL);
2388                 if (!ring->dma_pdma)
2389                         goto no_tx_mem;
2390
2391                 for (i = 0; i < ring_size; i++) {
2392                         ring->dma_pdma[i].txd2 = TX_DMA_DESP2_DEF;
2393                         ring->dma_pdma[i].txd4 = 0;
2394                 }
2395         }
2396
2397         ring->dma_size = ring_size;
2398         atomic_set(&ring->free_count, ring_size - 2);
2399         ring->next_free = ring->dma;
2400         ring->last_free = (void *)txd;
2401         ring->last_free_ptr = (u32)(ring->phys + ((ring_size - 1) * sz));
2402         ring->thresh = MAX_SKB_FRAGS;
2403
2404         /* make sure that all changes to the dma ring are flushed before we
2405          * continue
2406          */
2407         wmb();
2408
2409         if (MTK_HAS_CAPS(soc->caps, MTK_QDMA)) {
2410                 mtk_w32(eth, ring->phys, soc->reg_map->qdma.ctx_ptr);
2411                 mtk_w32(eth, ring->phys, soc->reg_map->qdma.dtx_ptr);
2412                 mtk_w32(eth,
2413                         ring->phys + ((ring_size - 1) * sz),
2414                         soc->reg_map->qdma.crx_ptr);
2415                 mtk_w32(eth, ring->last_free_ptr, soc->reg_map->qdma.drx_ptr);
2416
2417                 for (i = 0, ofs = 0; i < MTK_QDMA_NUM_QUEUES; i++) {
2418                         val = (QDMA_RES_THRES << 8) | QDMA_RES_THRES;
2419                         mtk_w32(eth, val, soc->reg_map->qdma.qtx_cfg + ofs);
2420
2421                         val = MTK_QTX_SCH_MIN_RATE_EN |
2422                               /* minimum: 10 Mbps */
2423                               FIELD_PREP(MTK_QTX_SCH_MIN_RATE_MAN, 1) |
2424                               FIELD_PREP(MTK_QTX_SCH_MIN_RATE_EXP, 4) |
2425                               MTK_QTX_SCH_LEAKY_BUCKET_SIZE;
2426                         if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
2427                                 val |= MTK_QTX_SCH_LEAKY_BUCKET_EN;
2428                         mtk_w32(eth, val, soc->reg_map->qdma.qtx_sch + ofs);
2429                         ofs += MTK_QTX_OFFSET;
2430                 }
2431                 val = MTK_QDMA_TX_SCH_MAX_WFQ | (MTK_QDMA_TX_SCH_MAX_WFQ << 16);
2432                 mtk_w32(eth, val, soc->reg_map->qdma.tx_sch_rate);
2433                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
2434                         mtk_w32(eth, val, soc->reg_map->qdma.tx_sch_rate + 4);
2435         } else {
2436                 mtk_w32(eth, ring->phys_pdma, MT7628_TX_BASE_PTR0);
2437                 mtk_w32(eth, ring_size, MT7628_TX_MAX_CNT0);
2438                 mtk_w32(eth, 0, MT7628_TX_CTX_IDX0);
2439                 mtk_w32(eth, MT7628_PST_DTX_IDX0, soc->reg_map->pdma.rst_idx);
2440         }
2441
2442         return 0;
2443
2444 no_tx_mem:
2445         return -ENOMEM;
2446 }
2447
2448 static void mtk_tx_clean(struct mtk_eth *eth)
2449 {
2450         const struct mtk_soc_data *soc = eth->soc;
2451         struct mtk_tx_ring *ring = &eth->tx_ring;
2452         int i;
2453
2454         if (ring->buf) {
2455                 for (i = 0; i < ring->dma_size; i++)
2456                         mtk_tx_unmap(eth, &ring->buf[i], NULL, false);
2457                 kfree(ring->buf);
2458                 ring->buf = NULL;
2459         }
2460
2461         if (ring->dma) {
2462                 dma_free_coherent(eth->dma_dev,
2463                                   ring->dma_size * soc->txrx.txd_size,
2464                                   ring->dma, ring->phys);
2465                 ring->dma = NULL;
2466         }
2467
2468         if (ring->dma_pdma) {
2469                 dma_free_coherent(eth->dma_dev,
2470                                   ring->dma_size * soc->txrx.txd_size,
2471                                   ring->dma_pdma, ring->phys_pdma);
2472                 ring->dma_pdma = NULL;
2473         }
2474 }
2475
2476 static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
2477 {
2478         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
2479         struct mtk_rx_ring *ring;
2480         int rx_data_len, rx_dma_size;
2481         int i;
2482
2483         if (rx_flag == MTK_RX_FLAGS_QDMA) {
2484                 if (ring_no)
2485                         return -EINVAL;
2486                 ring = &eth->rx_ring_qdma;
2487         } else {
2488                 ring = &eth->rx_ring[ring_no];
2489         }
2490
2491         if (rx_flag == MTK_RX_FLAGS_HWLRO) {
2492                 rx_data_len = MTK_MAX_LRO_RX_LENGTH;
2493                 rx_dma_size = MTK_HW_LRO_DMA_SIZE;
2494         } else {
2495                 rx_data_len = ETH_DATA_LEN;
2496                 rx_dma_size = MTK_DMA_SIZE;
2497         }
2498
2499         ring->frag_size = mtk_max_frag_size(rx_data_len);
2500         ring->buf_size = mtk_max_buf_size(ring->frag_size);
2501         ring->data = kcalloc(rx_dma_size, sizeof(*ring->data),
2502                              GFP_KERNEL);
2503         if (!ring->data)
2504                 return -ENOMEM;
2505
2506         if (mtk_page_pool_enabled(eth)) {
2507                 struct page_pool *pp;
2508
2509                 pp = mtk_create_page_pool(eth, &ring->xdp_q, ring_no,
2510                                           rx_dma_size);
2511                 if (IS_ERR(pp))
2512                         return PTR_ERR(pp);
2513
2514                 ring->page_pool = pp;
2515         }
2516
2517         ring->dma = dma_alloc_coherent(eth->dma_dev,
2518                                        rx_dma_size * eth->soc->txrx.rxd_size,
2519                                        &ring->phys, GFP_KERNEL);
2520         if (!ring->dma)
2521                 return -ENOMEM;
2522
2523         for (i = 0; i < rx_dma_size; i++) {
2524                 struct mtk_rx_dma_v2 *rxd;
2525                 dma_addr_t dma_addr;
2526                 void *data;
2527
2528                 rxd = ring->dma + i * eth->soc->txrx.rxd_size;
2529                 if (ring->page_pool) {
2530                         data = mtk_page_pool_get_buff(ring->page_pool,
2531                                                       &dma_addr, GFP_KERNEL);
2532                         if (!data)
2533                                 return -ENOMEM;
2534                 } else {
2535                         if (ring->frag_size <= PAGE_SIZE)
2536                                 data = netdev_alloc_frag(ring->frag_size);
2537                         else
2538                                 data = mtk_max_lro_buf_alloc(GFP_KERNEL);
2539
2540                         if (!data)
2541                                 return -ENOMEM;
2542
2543                         dma_addr = dma_map_single(eth->dma_dev,
2544                                 data + NET_SKB_PAD + eth->ip_align,
2545                                 ring->buf_size, DMA_FROM_DEVICE);
2546                         if (unlikely(dma_mapping_error(eth->dma_dev,
2547                                                        dma_addr))) {
2548                                 skb_free_frag(data);
2549                                 return -ENOMEM;
2550                         }
2551                 }
2552                 rxd->rxd1 = (unsigned int)dma_addr;
2553                 ring->data[i] = data;
2554
2555                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
2556                         rxd->rxd2 = RX_DMA_LSO;
2557                 else
2558                         rxd->rxd2 = RX_DMA_PREP_PLEN0(ring->buf_size);
2559
2560                 rxd->rxd3 = 0;
2561                 rxd->rxd4 = 0;
2562                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
2563                         rxd->rxd5 = 0;
2564                         rxd->rxd6 = 0;
2565                         rxd->rxd7 = 0;
2566                         rxd->rxd8 = 0;
2567                 }
2568         }
2569
2570         ring->dma_size = rx_dma_size;
2571         ring->calc_idx_update = false;
2572         ring->calc_idx = rx_dma_size - 1;
2573         if (rx_flag == MTK_RX_FLAGS_QDMA)
2574                 ring->crx_idx_reg = reg_map->qdma.qcrx_ptr +
2575                                     ring_no * MTK_QRX_OFFSET;
2576         else
2577                 ring->crx_idx_reg = reg_map->pdma.pcrx_ptr +
2578                                     ring_no * MTK_QRX_OFFSET;
2579         /* make sure that all changes to the dma ring are flushed before we
2580          * continue
2581          */
2582         wmb();
2583
2584         if (rx_flag == MTK_RX_FLAGS_QDMA) {
2585                 mtk_w32(eth, ring->phys,
2586                         reg_map->qdma.rx_ptr + ring_no * MTK_QRX_OFFSET);
2587                 mtk_w32(eth, rx_dma_size,
2588                         reg_map->qdma.rx_cnt_cfg + ring_no * MTK_QRX_OFFSET);
2589                 mtk_w32(eth, MTK_PST_DRX_IDX_CFG(ring_no),
2590                         reg_map->qdma.rst_idx);
2591         } else {
2592                 mtk_w32(eth, ring->phys,
2593                         reg_map->pdma.rx_ptr + ring_no * MTK_QRX_OFFSET);
2594                 mtk_w32(eth, rx_dma_size,
2595                         reg_map->pdma.rx_cnt_cfg + ring_no * MTK_QRX_OFFSET);
2596                 mtk_w32(eth, MTK_PST_DRX_IDX_CFG(ring_no),
2597                         reg_map->pdma.rst_idx);
2598         }
2599         mtk_w32(eth, ring->calc_idx, ring->crx_idx_reg);
2600
2601         return 0;
2602 }
2603
2604 static void mtk_rx_clean(struct mtk_eth *eth, struct mtk_rx_ring *ring)
2605 {
2606         int i;
2607
2608         if (ring->data && ring->dma) {
2609                 for (i = 0; i < ring->dma_size; i++) {
2610                         struct mtk_rx_dma *rxd;
2611
2612                         if (!ring->data[i])
2613                                 continue;
2614
2615                         rxd = ring->dma + i * eth->soc->txrx.rxd_size;
2616                         if (!rxd->rxd1)
2617                                 continue;
2618
2619                         dma_unmap_single(eth->dma_dev, rxd->rxd1,
2620                                          ring->buf_size, DMA_FROM_DEVICE);
2621                         mtk_rx_put_buff(ring, ring->data[i], false);
2622                 }
2623                 kfree(ring->data);
2624                 ring->data = NULL;
2625         }
2626
2627         if (ring->dma) {
2628                 dma_free_coherent(eth->dma_dev,
2629                                   ring->dma_size * eth->soc->txrx.rxd_size,
2630                                   ring->dma, ring->phys);
2631                 ring->dma = NULL;
2632         }
2633
2634         if (ring->page_pool) {
2635                 if (xdp_rxq_info_is_reg(&ring->xdp_q))
2636                         xdp_rxq_info_unreg(&ring->xdp_q);
2637                 page_pool_destroy(ring->page_pool);
2638                 ring->page_pool = NULL;
2639         }
2640 }
2641
2642 static int mtk_hwlro_rx_init(struct mtk_eth *eth)
2643 {
2644         int i;
2645         u32 ring_ctrl_dw1 = 0, ring_ctrl_dw2 = 0, ring_ctrl_dw3 = 0;
2646         u32 lro_ctrl_dw0 = 0, lro_ctrl_dw3 = 0;
2647
2648         /* set LRO rings to auto-learn modes */
2649         ring_ctrl_dw2 |= MTK_RING_AUTO_LERAN_MODE;
2650
2651         /* validate LRO ring */
2652         ring_ctrl_dw2 |= MTK_RING_VLD;
2653
2654         /* set AGE timer (unit: 20us) */
2655         ring_ctrl_dw2 |= MTK_RING_AGE_TIME_H;
2656         ring_ctrl_dw1 |= MTK_RING_AGE_TIME_L;
2657
2658         /* set max AGG timer (unit: 20us) */
2659         ring_ctrl_dw2 |= MTK_RING_MAX_AGG_TIME;
2660
2661         /* set max LRO AGG count */
2662         ring_ctrl_dw2 |= MTK_RING_MAX_AGG_CNT_L;
2663         ring_ctrl_dw3 |= MTK_RING_MAX_AGG_CNT_H;
2664
2665         for (i = 1; i < MTK_MAX_RX_RING_NUM; i++) {
2666                 mtk_w32(eth, ring_ctrl_dw1, MTK_LRO_CTRL_DW1_CFG(i));
2667                 mtk_w32(eth, ring_ctrl_dw2, MTK_LRO_CTRL_DW2_CFG(i));
2668                 mtk_w32(eth, ring_ctrl_dw3, MTK_LRO_CTRL_DW3_CFG(i));
2669         }
2670
2671         /* IPv4 checksum update enable */
2672         lro_ctrl_dw0 |= MTK_L3_CKS_UPD_EN;
2673
2674         /* switch priority comparison to packet count mode */
2675         lro_ctrl_dw0 |= MTK_LRO_ALT_PKT_CNT_MODE;
2676
2677         /* bandwidth threshold setting */
2678         mtk_w32(eth, MTK_HW_LRO_BW_THRE, MTK_PDMA_LRO_CTRL_DW2);
2679
2680         /* auto-learn score delta setting */
2681         mtk_w32(eth, MTK_HW_LRO_REPLACE_DELTA, MTK_PDMA_LRO_ALT_SCORE_DELTA);
2682
2683         /* set refresh timer for altering flows to 1 sec. (unit: 20us) */
2684         mtk_w32(eth, (MTK_HW_LRO_TIMER_UNIT << 16) | MTK_HW_LRO_REFRESH_TIME,
2685                 MTK_PDMA_LRO_ALT_REFRESH_TIMER);
2686
2687         /* set HW LRO mode & the max aggregation count for rx packets */
2688         lro_ctrl_dw3 |= MTK_ADMA_MODE | (MTK_HW_LRO_MAX_AGG_CNT & 0xff);
2689
2690         /* the minimal remaining room of SDL0 in RXD for lro aggregation */
2691         lro_ctrl_dw3 |= MTK_LRO_MIN_RXD_SDL;
2692
2693         /* enable HW LRO */
2694         lro_ctrl_dw0 |= MTK_LRO_EN;
2695
2696         mtk_w32(eth, lro_ctrl_dw3, MTK_PDMA_LRO_CTRL_DW3);
2697         mtk_w32(eth, lro_ctrl_dw0, MTK_PDMA_LRO_CTRL_DW0);
2698
2699         return 0;
2700 }
2701
2702 static void mtk_hwlro_rx_uninit(struct mtk_eth *eth)
2703 {
2704         int i;
2705         u32 val;
2706
2707         /* relinquish lro rings, flush aggregated packets */
2708         mtk_w32(eth, MTK_LRO_RING_RELINQUISH_REQ, MTK_PDMA_LRO_CTRL_DW0);
2709
2710         /* wait for relinquishments done */
2711         for (i = 0; i < 10; i++) {
2712                 val = mtk_r32(eth, MTK_PDMA_LRO_CTRL_DW0);
2713                 if (val & MTK_LRO_RING_RELINQUISH_DONE) {
2714                         msleep(20);
2715                         continue;
2716                 }
2717                 break;
2718         }
2719
2720         /* invalidate lro rings */
2721         for (i = 1; i < MTK_MAX_RX_RING_NUM; i++)
2722                 mtk_w32(eth, 0, MTK_LRO_CTRL_DW2_CFG(i));
2723
2724         /* disable HW LRO */
2725         mtk_w32(eth, 0, MTK_PDMA_LRO_CTRL_DW0);
2726 }
2727
2728 static void mtk_hwlro_val_ipaddr(struct mtk_eth *eth, int idx, __be32 ip)
2729 {
2730         u32 reg_val;
2731
2732         reg_val = mtk_r32(eth, MTK_LRO_CTRL_DW2_CFG(idx));
2733
2734         /* invalidate the IP setting */
2735         mtk_w32(eth, (reg_val & ~MTK_RING_MYIP_VLD), MTK_LRO_CTRL_DW2_CFG(idx));
2736
2737         mtk_w32(eth, ip, MTK_LRO_DIP_DW0_CFG(idx));
2738
2739         /* validate the IP setting */
2740         mtk_w32(eth, (reg_val | MTK_RING_MYIP_VLD), MTK_LRO_CTRL_DW2_CFG(idx));
2741 }
2742
2743 static void mtk_hwlro_inval_ipaddr(struct mtk_eth *eth, int idx)
2744 {
2745         u32 reg_val;
2746
2747         reg_val = mtk_r32(eth, MTK_LRO_CTRL_DW2_CFG(idx));
2748
2749         /* invalidate the IP setting */
2750         mtk_w32(eth, (reg_val & ~MTK_RING_MYIP_VLD), MTK_LRO_CTRL_DW2_CFG(idx));
2751
2752         mtk_w32(eth, 0, MTK_LRO_DIP_DW0_CFG(idx));
2753 }
2754
2755 static int mtk_hwlro_get_ip_cnt(struct mtk_mac *mac)
2756 {
2757         int cnt = 0;
2758         int i;
2759
2760         for (i = 0; i < MTK_MAX_LRO_IP_CNT; i++) {
2761                 if (mac->hwlro_ip[i])
2762                         cnt++;
2763         }
2764
2765         return cnt;
2766 }
2767
2768 static int mtk_hwlro_add_ipaddr(struct net_device *dev,
2769                                 struct ethtool_rxnfc *cmd)
2770 {
2771         struct ethtool_rx_flow_spec *fsp =
2772                 (struct ethtool_rx_flow_spec *)&cmd->fs;
2773         struct mtk_mac *mac = netdev_priv(dev);
2774         struct mtk_eth *eth = mac->hw;
2775         int hwlro_idx;
2776
2777         if ((fsp->flow_type != TCP_V4_FLOW) ||
2778             (!fsp->h_u.tcp_ip4_spec.ip4dst) ||
2779             (fsp->location > 1))
2780                 return -EINVAL;
2781
2782         mac->hwlro_ip[fsp->location] = htonl(fsp->h_u.tcp_ip4_spec.ip4dst);
2783         hwlro_idx = (mac->id * MTK_MAX_LRO_IP_CNT) + fsp->location;
2784
2785         mac->hwlro_ip_cnt = mtk_hwlro_get_ip_cnt(mac);
2786
2787         mtk_hwlro_val_ipaddr(eth, hwlro_idx, mac->hwlro_ip[fsp->location]);
2788
2789         return 0;
2790 }
2791
2792 static int mtk_hwlro_del_ipaddr(struct net_device *dev,
2793                                 struct ethtool_rxnfc *cmd)
2794 {
2795         struct ethtool_rx_flow_spec *fsp =
2796                 (struct ethtool_rx_flow_spec *)&cmd->fs;
2797         struct mtk_mac *mac = netdev_priv(dev);
2798         struct mtk_eth *eth = mac->hw;
2799         int hwlro_idx;
2800
2801         if (fsp->location > 1)
2802                 return -EINVAL;
2803
2804         mac->hwlro_ip[fsp->location] = 0;
2805         hwlro_idx = (mac->id * MTK_MAX_LRO_IP_CNT) + fsp->location;
2806
2807         mac->hwlro_ip_cnt = mtk_hwlro_get_ip_cnt(mac);
2808
2809         mtk_hwlro_inval_ipaddr(eth, hwlro_idx);
2810
2811         return 0;
2812 }
2813
2814 static void mtk_hwlro_netdev_disable(struct net_device *dev)
2815 {
2816         struct mtk_mac *mac = netdev_priv(dev);
2817         struct mtk_eth *eth = mac->hw;
2818         int i, hwlro_idx;
2819
2820         for (i = 0; i < MTK_MAX_LRO_IP_CNT; i++) {
2821                 mac->hwlro_ip[i] = 0;
2822                 hwlro_idx = (mac->id * MTK_MAX_LRO_IP_CNT) + i;
2823
2824                 mtk_hwlro_inval_ipaddr(eth, hwlro_idx);
2825         }
2826
2827         mac->hwlro_ip_cnt = 0;
2828 }
2829
2830 static int mtk_hwlro_get_fdir_entry(struct net_device *dev,
2831                                     struct ethtool_rxnfc *cmd)
2832 {
2833         struct mtk_mac *mac = netdev_priv(dev);
2834         struct ethtool_rx_flow_spec *fsp =
2835                 (struct ethtool_rx_flow_spec *)&cmd->fs;
2836
2837         if (fsp->location >= ARRAY_SIZE(mac->hwlro_ip))
2838                 return -EINVAL;
2839
2840         /* only tcp dst ipv4 is meaningful, others are meaningless */
2841         fsp->flow_type = TCP_V4_FLOW;
2842         fsp->h_u.tcp_ip4_spec.ip4dst = ntohl(mac->hwlro_ip[fsp->location]);
2843         fsp->m_u.tcp_ip4_spec.ip4dst = 0;
2844
2845         fsp->h_u.tcp_ip4_spec.ip4src = 0;
2846         fsp->m_u.tcp_ip4_spec.ip4src = 0xffffffff;
2847         fsp->h_u.tcp_ip4_spec.psrc = 0;
2848         fsp->m_u.tcp_ip4_spec.psrc = 0xffff;
2849         fsp->h_u.tcp_ip4_spec.pdst = 0;
2850         fsp->m_u.tcp_ip4_spec.pdst = 0xffff;
2851         fsp->h_u.tcp_ip4_spec.tos = 0;
2852         fsp->m_u.tcp_ip4_spec.tos = 0xff;
2853
2854         return 0;
2855 }
2856
2857 static int mtk_hwlro_get_fdir_all(struct net_device *dev,
2858                                   struct ethtool_rxnfc *cmd,
2859                                   u32 *rule_locs)
2860 {
2861         struct mtk_mac *mac = netdev_priv(dev);
2862         int cnt = 0;
2863         int i;
2864
2865         for (i = 0; i < MTK_MAX_LRO_IP_CNT; i++) {
2866                 if (mac->hwlro_ip[i]) {
2867                         rule_locs[cnt] = i;
2868                         cnt++;
2869                 }
2870         }
2871
2872         cmd->rule_cnt = cnt;
2873
2874         return 0;
2875 }
2876
2877 static netdev_features_t mtk_fix_features(struct net_device *dev,
2878                                           netdev_features_t features)
2879 {
2880         if (!(features & NETIF_F_LRO)) {
2881                 struct mtk_mac *mac = netdev_priv(dev);
2882                 int ip_cnt = mtk_hwlro_get_ip_cnt(mac);
2883
2884                 if (ip_cnt) {
2885                         netdev_info(dev, "RX flow is programmed, LRO should keep on\n");
2886
2887                         features |= NETIF_F_LRO;
2888                 }
2889         }
2890
2891         return features;
2892 }
2893
2894 static int mtk_set_features(struct net_device *dev, netdev_features_t features)
2895 {
2896         netdev_features_t diff = dev->features ^ features;
2897
2898         if ((diff & NETIF_F_LRO) && !(features & NETIF_F_LRO))
2899                 mtk_hwlro_netdev_disable(dev);
2900
2901         return 0;
2902 }
2903
2904 /* wait for DMA to finish whatever it is doing before we start using it again */
2905 static int mtk_dma_busy_wait(struct mtk_eth *eth)
2906 {
2907         unsigned int reg;
2908         int ret;
2909         u32 val;
2910
2911         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
2912                 reg = eth->soc->reg_map->qdma.glo_cfg;
2913         else
2914                 reg = eth->soc->reg_map->pdma.glo_cfg;
2915
2916         ret = readx_poll_timeout_atomic(__raw_readl, eth->base + reg, val,
2917                                         !(val & (MTK_RX_DMA_BUSY | MTK_TX_DMA_BUSY)),
2918                                         5, MTK_DMA_BUSY_TIMEOUT_US);
2919         if (ret)
2920                 dev_err(eth->dev, "DMA init timeout\n");
2921
2922         return ret;
2923 }
2924
2925 static int mtk_dma_init(struct mtk_eth *eth)
2926 {
2927         int err;
2928         u32 i;
2929
2930         if (mtk_dma_busy_wait(eth))
2931                 return -EBUSY;
2932
2933         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
2934                 /* QDMA needs scratch memory for internal reordering of the
2935                  * descriptors
2936                  */
2937                 err = mtk_init_fq_dma(eth);
2938                 if (err)
2939                         return err;
2940         }
2941
2942         err = mtk_tx_alloc(eth);
2943         if (err)
2944                 return err;
2945
2946         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
2947                 err = mtk_rx_alloc(eth, 0, MTK_RX_FLAGS_QDMA);
2948                 if (err)
2949                         return err;
2950         }
2951
2952         err = mtk_rx_alloc(eth, 0, MTK_RX_FLAGS_NORMAL);
2953         if (err)
2954                 return err;
2955
2956         if (eth->hwlro) {
2957                 for (i = 1; i < MTK_MAX_RX_RING_NUM; i++) {
2958                         err = mtk_rx_alloc(eth, i, MTK_RX_FLAGS_HWLRO);
2959                         if (err)
2960                                 return err;
2961                 }
2962                 err = mtk_hwlro_rx_init(eth);
2963                 if (err)
2964                         return err;
2965         }
2966
2967         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
2968                 /* Enable random early drop and set drop threshold
2969                  * automatically
2970                  */
2971                 mtk_w32(eth, FC_THRES_DROP_MODE | FC_THRES_DROP_EN |
2972                         FC_THRES_MIN, eth->soc->reg_map->qdma.fc_th);
2973                 mtk_w32(eth, 0x0, eth->soc->reg_map->qdma.hred);
2974         }
2975
2976         return 0;
2977 }
2978
2979 static void mtk_dma_free(struct mtk_eth *eth)
2980 {
2981         const struct mtk_soc_data *soc = eth->soc;
2982         int i;
2983
2984         for (i = 0; i < MTK_MAC_COUNT; i++)
2985                 if (eth->netdev[i])
2986                         netdev_reset_queue(eth->netdev[i]);
2987         if (eth->scratch_ring) {
2988                 dma_free_coherent(eth->dma_dev,
2989                                   MTK_QDMA_RING_SIZE * soc->txrx.txd_size,
2990                                   eth->scratch_ring, eth->phy_scratch_ring);
2991                 eth->scratch_ring = NULL;
2992                 eth->phy_scratch_ring = 0;
2993         }
2994         mtk_tx_clean(eth);
2995         mtk_rx_clean(eth, &eth->rx_ring[0]);
2996         mtk_rx_clean(eth, &eth->rx_ring_qdma);
2997
2998         if (eth->hwlro) {
2999                 mtk_hwlro_rx_uninit(eth);
3000                 for (i = 1; i < MTK_MAX_RX_RING_NUM; i++)
3001                         mtk_rx_clean(eth, &eth->rx_ring[i]);
3002         }
3003
3004         kfree(eth->scratch_head);
3005 }
3006
3007 static bool mtk_hw_reset_check(struct mtk_eth *eth)
3008 {
3009         u32 val = mtk_r32(eth, MTK_INT_STATUS2);
3010
3011         return (val & MTK_FE_INT_FQ_EMPTY) || (val & MTK_FE_INT_RFIFO_UF) ||
3012                (val & MTK_FE_INT_RFIFO_OV) || (val & MTK_FE_INT_TSO_FAIL) ||
3013                (val & MTK_FE_INT_TSO_ALIGN) || (val & MTK_FE_INT_TSO_ILLEGAL);
3014 }
3015
3016 static void mtk_tx_timeout(struct net_device *dev, unsigned int txqueue)
3017 {
3018         struct mtk_mac *mac = netdev_priv(dev);
3019         struct mtk_eth *eth = mac->hw;
3020
3021         if (test_bit(MTK_RESETTING, &eth->state))
3022                 return;
3023
3024         if (!mtk_hw_reset_check(eth))
3025                 return;
3026
3027         eth->netdev[mac->id]->stats.tx_errors++;
3028         netif_err(eth, tx_err, dev, "transmit timed out\n");
3029
3030         schedule_work(&eth->pending_work);
3031 }
3032
3033 static irqreturn_t mtk_handle_irq_rx(int irq, void *_eth)
3034 {
3035         struct mtk_eth *eth = _eth;
3036
3037         eth->rx_events++;
3038         if (likely(napi_schedule_prep(&eth->rx_napi))) {
3039                 __napi_schedule(&eth->rx_napi);
3040                 mtk_rx_irq_disable(eth, eth->soc->txrx.rx_irq_done_mask);
3041         }
3042
3043         return IRQ_HANDLED;
3044 }
3045
3046 static irqreturn_t mtk_handle_irq_tx(int irq, void *_eth)
3047 {
3048         struct mtk_eth *eth = _eth;
3049
3050         eth->tx_events++;
3051         if (likely(napi_schedule_prep(&eth->tx_napi))) {
3052                 __napi_schedule(&eth->tx_napi);
3053                 mtk_tx_irq_disable(eth, MTK_TX_DONE_INT);
3054         }
3055
3056         return IRQ_HANDLED;
3057 }
3058
3059 static irqreturn_t mtk_handle_irq(int irq, void *_eth)
3060 {
3061         struct mtk_eth *eth = _eth;
3062         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
3063
3064         if (mtk_r32(eth, reg_map->pdma.irq_mask) &
3065             eth->soc->txrx.rx_irq_done_mask) {
3066                 if (mtk_r32(eth, reg_map->pdma.irq_status) &
3067                     eth->soc->txrx.rx_irq_done_mask)
3068                         mtk_handle_irq_rx(irq, _eth);
3069         }
3070         if (mtk_r32(eth, reg_map->tx_irq_mask) & MTK_TX_DONE_INT) {
3071                 if (mtk_r32(eth, reg_map->tx_irq_status) & MTK_TX_DONE_INT)
3072                         mtk_handle_irq_tx(irq, _eth);
3073         }
3074
3075         return IRQ_HANDLED;
3076 }
3077
3078 #ifdef CONFIG_NET_POLL_CONTROLLER
3079 static void mtk_poll_controller(struct net_device *dev)
3080 {
3081         struct mtk_mac *mac = netdev_priv(dev);
3082         struct mtk_eth *eth = mac->hw;
3083
3084         mtk_tx_irq_disable(eth, MTK_TX_DONE_INT);
3085         mtk_rx_irq_disable(eth, eth->soc->txrx.rx_irq_done_mask);
3086         mtk_handle_irq_rx(eth->irq[2], dev);
3087         mtk_tx_irq_enable(eth, MTK_TX_DONE_INT);
3088         mtk_rx_irq_enable(eth, eth->soc->txrx.rx_irq_done_mask);
3089 }
3090 #endif
3091
3092 static int mtk_start_dma(struct mtk_eth *eth)
3093 {
3094         u32 val, rx_2b_offset = (NET_IP_ALIGN == 2) ? MTK_RX_2B_OFFSET : 0;
3095         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
3096         int err;
3097
3098         err = mtk_dma_init(eth);
3099         if (err) {
3100                 mtk_dma_free(eth);
3101                 return err;
3102         }
3103
3104         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
3105                 val = mtk_r32(eth, reg_map->qdma.glo_cfg);
3106                 val |= MTK_TX_DMA_EN | MTK_RX_DMA_EN |
3107                        MTK_TX_BT_32DWORDS | MTK_NDP_CO_PRO |
3108                        MTK_RX_2B_OFFSET | MTK_TX_WB_DDONE;
3109
3110                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
3111                         val |= MTK_MUTLI_CNT | MTK_RESV_BUF |
3112                                MTK_WCOMP_EN | MTK_DMAD_WR_WDONE |
3113                                MTK_CHK_DDONE_EN | MTK_LEAKY_BUCKET_EN;
3114                 else
3115                         val |= MTK_RX_BT_32DWORDS;
3116                 mtk_w32(eth, val, reg_map->qdma.glo_cfg);
3117
3118                 mtk_w32(eth,
3119                         MTK_RX_DMA_EN | rx_2b_offset |
3120                         MTK_RX_BT_32DWORDS | MTK_MULTI_EN,
3121                         reg_map->pdma.glo_cfg);
3122         } else {
3123                 mtk_w32(eth, MTK_TX_WB_DDONE | MTK_TX_DMA_EN | MTK_RX_DMA_EN |
3124                         MTK_MULTI_EN | MTK_PDMA_SIZE_8DWORDS,
3125                         reg_map->pdma.glo_cfg);
3126         }
3127
3128         return 0;
3129 }
3130
3131 static void mtk_gdm_config(struct mtk_eth *eth, u32 config)
3132 {
3133         int i;
3134
3135         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
3136                 return;
3137
3138         for (i = 0; i < MTK_MAC_COUNT; i++) {
3139                 u32 val = mtk_r32(eth, MTK_GDMA_FWD_CFG(i));
3140
3141                 /* default setup the forward port to send frame to PDMA */
3142                 val &= ~0xffff;
3143
3144                 /* Enable RX checksum */
3145                 val |= MTK_GDMA_ICS_EN | MTK_GDMA_TCS_EN | MTK_GDMA_UCS_EN;
3146
3147                 val |= config;
3148
3149                 if (eth->netdev[i] && netdev_uses_dsa(eth->netdev[i]))
3150                         val |= MTK_GDMA_SPECIAL_TAG;
3151
3152                 mtk_w32(eth, val, MTK_GDMA_FWD_CFG(i));
3153         }
3154         /* Reset and enable PSE */
3155         mtk_w32(eth, RST_GL_PSE, MTK_RST_GL);
3156         mtk_w32(eth, 0, MTK_RST_GL);
3157 }
3158
3159
3160 static bool mtk_uses_dsa(struct net_device *dev)
3161 {
3162 #if IS_ENABLED(CONFIG_NET_DSA)
3163         return netdev_uses_dsa(dev) &&
3164                dev->dsa_ptr->tag_ops->proto == DSA_TAG_PROTO_MTK;
3165 #else
3166         return false;
3167 #endif
3168 }
3169
3170 static int mtk_device_event(struct notifier_block *n, unsigned long event, void *ptr)
3171 {
3172         struct mtk_mac *mac = container_of(n, struct mtk_mac, device_notifier);
3173         struct mtk_eth *eth = mac->hw;
3174         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
3175         struct ethtool_link_ksettings s;
3176         struct net_device *ldev;
3177         struct list_head *iter;
3178         struct dsa_port *dp;
3179
3180         if (event != NETDEV_CHANGE)
3181                 return NOTIFY_DONE;
3182
3183         netdev_for_each_lower_dev(dev, ldev, iter) {
3184                 if (netdev_priv(ldev) == mac)
3185                         goto found;
3186         }
3187
3188         return NOTIFY_DONE;
3189
3190 found:
3191         if (!dsa_slave_dev_check(dev))
3192                 return NOTIFY_DONE;
3193
3194         if (__ethtool_get_link_ksettings(dev, &s))
3195                 return NOTIFY_DONE;
3196
3197         if (s.base.speed == 0 || s.base.speed == ((__u32)-1))
3198                 return NOTIFY_DONE;
3199
3200         dp = dsa_port_from_netdev(dev);
3201         if (dp->index >= MTK_QDMA_NUM_QUEUES)
3202                 return NOTIFY_DONE;
3203
3204         if (mac->speed > 0 && mac->speed <= s.base.speed)
3205                 s.base.speed = 0;
3206
3207         mtk_set_queue_speed(eth, dp->index + 3, s.base.speed);
3208
3209         return NOTIFY_DONE;
3210 }
3211
3212 static int mtk_open(struct net_device *dev)
3213 {
3214         struct mtk_mac *mac = netdev_priv(dev);
3215         struct mtk_eth *eth = mac->hw;
3216         int i, err;
3217
3218         err = phylink_of_phy_connect(mac->phylink, mac->of_node, 0);
3219         if (err) {
3220                 netdev_err(dev, "%s: could not attach PHY: %d\n", __func__,
3221                            err);
3222                 return err;
3223         }
3224
3225         /* we run 2 netdevs on the same dma ring so we only bring it up once */
3226         if (!refcount_read(&eth->dma_refcnt)) {
3227                 const struct mtk_soc_data *soc = eth->soc;
3228                 u32 gdm_config;
3229                 int i;
3230
3231                 err = mtk_start_dma(eth);
3232                 if (err) {
3233                         phylink_disconnect_phy(mac->phylink);
3234                         return err;
3235                 }
3236
3237                 for (i = 0; i < ARRAY_SIZE(eth->ppe); i++)
3238                         mtk_ppe_start(eth->ppe[i]);
3239
3240                 gdm_config = soc->offload_version ? soc->reg_map->gdma_to_ppe
3241                                                   : MTK_GDMA_TO_PDMA;
3242                 mtk_gdm_config(eth, gdm_config);
3243
3244                 napi_enable(&eth->tx_napi);
3245                 napi_enable(&eth->rx_napi);
3246                 mtk_tx_irq_enable(eth, MTK_TX_DONE_INT);
3247                 mtk_rx_irq_enable(eth, soc->txrx.rx_irq_done_mask);
3248                 refcount_set(&eth->dma_refcnt, 1);
3249         }
3250         else
3251                 refcount_inc(&eth->dma_refcnt);
3252
3253         phylink_start(mac->phylink);
3254         netif_tx_start_all_queues(dev);
3255
3256         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
3257                 return 0;
3258
3259         if (mtk_uses_dsa(dev) && !eth->prog) {
3260                 for (i = 0; i < ARRAY_SIZE(eth->dsa_meta); i++) {
3261                         struct metadata_dst *md_dst = eth->dsa_meta[i];
3262
3263                         if (md_dst)
3264                                 continue;
3265
3266                         md_dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
3267                                                     GFP_KERNEL);
3268                         if (!md_dst)
3269                                 return -ENOMEM;
3270
3271                         md_dst->u.port_info.port_id = i;
3272                         eth->dsa_meta[i] = md_dst;
3273                 }
3274         } else {
3275                 /* Hardware DSA untagging and VLAN RX offloading need to be
3276                  * disabled if at least one MAC does not use DSA.
3277                  */
3278                 u32 val = mtk_r32(eth, MTK_CDMP_IG_CTRL);
3279
3280                 val &= ~MTK_CDMP_STAG_EN;
3281                 mtk_w32(eth, val, MTK_CDMP_IG_CTRL);
3282
3283                 mtk_w32(eth, 0, MTK_CDMP_EG_CTRL);
3284         }
3285
3286         return 0;
3287 }
3288
3289 static void mtk_stop_dma(struct mtk_eth *eth, u32 glo_cfg)
3290 {
3291         u32 val;
3292         int i;
3293
3294         /* stop the dma engine */
3295         spin_lock_bh(&eth->page_lock);
3296         val = mtk_r32(eth, glo_cfg);
3297         mtk_w32(eth, val & ~(MTK_TX_WB_DDONE | MTK_RX_DMA_EN | MTK_TX_DMA_EN),
3298                 glo_cfg);
3299         spin_unlock_bh(&eth->page_lock);
3300
3301         /* wait for dma stop */
3302         for (i = 0; i < 10; i++) {
3303                 val = mtk_r32(eth, glo_cfg);
3304                 if (val & (MTK_TX_DMA_BUSY | MTK_RX_DMA_BUSY)) {
3305                         msleep(20);
3306                         continue;
3307                 }
3308                 break;
3309         }
3310 }
3311
3312 static int mtk_stop(struct net_device *dev)
3313 {
3314         struct mtk_mac *mac = netdev_priv(dev);
3315         struct mtk_eth *eth = mac->hw;
3316         int i;
3317
3318         phylink_stop(mac->phylink);
3319
3320         netif_tx_disable(dev);
3321
3322         phylink_disconnect_phy(mac->phylink);
3323
3324         /* only shutdown DMA if this is the last user */
3325         if (!refcount_dec_and_test(&eth->dma_refcnt))
3326                 return 0;
3327
3328         mtk_gdm_config(eth, MTK_GDMA_DROP_ALL);
3329
3330         mtk_tx_irq_disable(eth, MTK_TX_DONE_INT);
3331         mtk_rx_irq_disable(eth, eth->soc->txrx.rx_irq_done_mask);
3332         napi_disable(&eth->tx_napi);
3333         napi_disable(&eth->rx_napi);
3334
3335         cancel_work_sync(&eth->rx_dim.work);
3336         cancel_work_sync(&eth->tx_dim.work);
3337
3338         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
3339                 mtk_stop_dma(eth, eth->soc->reg_map->qdma.glo_cfg);
3340         mtk_stop_dma(eth, eth->soc->reg_map->pdma.glo_cfg);
3341
3342         mtk_dma_free(eth);
3343
3344         for (i = 0; i < ARRAY_SIZE(eth->ppe); i++)
3345                 mtk_ppe_stop(eth->ppe[i]);
3346
3347         return 0;
3348 }
3349
3350 static int mtk_xdp_setup(struct net_device *dev, struct bpf_prog *prog,
3351                          struct netlink_ext_ack *extack)
3352 {
3353         struct mtk_mac *mac = netdev_priv(dev);
3354         struct mtk_eth *eth = mac->hw;
3355         struct bpf_prog *old_prog;
3356         bool need_update;
3357
3358         if (eth->hwlro) {
3359                 NL_SET_ERR_MSG_MOD(extack, "XDP not supported with HWLRO");
3360                 return -EOPNOTSUPP;
3361         }
3362
3363         if (dev->mtu > MTK_PP_MAX_BUF_SIZE) {
3364                 NL_SET_ERR_MSG_MOD(extack, "MTU too large for XDP");
3365                 return -EOPNOTSUPP;
3366         }
3367
3368         need_update = !!eth->prog != !!prog;
3369         if (netif_running(dev) && need_update)
3370                 mtk_stop(dev);
3371
3372         old_prog = rcu_replace_pointer(eth->prog, prog, lockdep_rtnl_is_held());
3373         if (old_prog)
3374                 bpf_prog_put(old_prog);
3375
3376         if (netif_running(dev) && need_update)
3377                 return mtk_open(dev);
3378
3379         return 0;
3380 }
3381
3382 static int mtk_xdp(struct net_device *dev, struct netdev_bpf *xdp)
3383 {
3384         switch (xdp->command) {
3385         case XDP_SETUP_PROG:
3386                 return mtk_xdp_setup(dev, xdp->prog, xdp->extack);
3387         default:
3388                 return -EINVAL;
3389         }
3390 }
3391
3392 static void ethsys_reset(struct mtk_eth *eth, u32 reset_bits)
3393 {
3394         regmap_update_bits(eth->ethsys, ETHSYS_RSTCTRL,
3395                            reset_bits,
3396                            reset_bits);
3397
3398         usleep_range(1000, 1100);
3399         regmap_update_bits(eth->ethsys, ETHSYS_RSTCTRL,
3400                            reset_bits,
3401                            ~reset_bits);
3402         mdelay(10);
3403 }
3404
3405 static void mtk_clk_disable(struct mtk_eth *eth)
3406 {
3407         int clk;
3408
3409         for (clk = MTK_CLK_MAX - 1; clk >= 0; clk--)
3410                 clk_disable_unprepare(eth->clks[clk]);
3411 }
3412
3413 static int mtk_clk_enable(struct mtk_eth *eth)
3414 {
3415         int clk, ret;
3416
3417         for (clk = 0; clk < MTK_CLK_MAX ; clk++) {
3418                 ret = clk_prepare_enable(eth->clks[clk]);
3419                 if (ret)
3420                         goto err_disable_clks;
3421         }
3422
3423         return 0;
3424
3425 err_disable_clks:
3426         while (--clk >= 0)
3427                 clk_disable_unprepare(eth->clks[clk]);
3428
3429         return ret;
3430 }
3431
3432 static void mtk_dim_rx(struct work_struct *work)
3433 {
3434         struct dim *dim = container_of(work, struct dim, work);
3435         struct mtk_eth *eth = container_of(dim, struct mtk_eth, rx_dim);
3436         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
3437         struct dim_cq_moder cur_profile;
3438         u32 val, cur;
3439
3440         cur_profile = net_dim_get_rx_moderation(eth->rx_dim.mode,
3441                                                 dim->profile_ix);
3442         spin_lock_bh(&eth->dim_lock);
3443
3444         val = mtk_r32(eth, reg_map->pdma.delay_irq);
3445         val &= MTK_PDMA_DELAY_TX_MASK;
3446         val |= MTK_PDMA_DELAY_RX_EN;
3447
3448         cur = min_t(u32, DIV_ROUND_UP(cur_profile.usec, 20), MTK_PDMA_DELAY_PTIME_MASK);
3449         val |= cur << MTK_PDMA_DELAY_RX_PTIME_SHIFT;
3450
3451         cur = min_t(u32, cur_profile.pkts, MTK_PDMA_DELAY_PINT_MASK);
3452         val |= cur << MTK_PDMA_DELAY_RX_PINT_SHIFT;
3453
3454         mtk_w32(eth, val, reg_map->pdma.delay_irq);
3455         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
3456                 mtk_w32(eth, val, reg_map->qdma.delay_irq);
3457
3458         spin_unlock_bh(&eth->dim_lock);
3459
3460         dim->state = DIM_START_MEASURE;
3461 }
3462
3463 static void mtk_dim_tx(struct work_struct *work)
3464 {
3465         struct dim *dim = container_of(work, struct dim, work);
3466         struct mtk_eth *eth = container_of(dim, struct mtk_eth, tx_dim);
3467         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
3468         struct dim_cq_moder cur_profile;
3469         u32 val, cur;
3470
3471         cur_profile = net_dim_get_tx_moderation(eth->tx_dim.mode,
3472                                                 dim->profile_ix);
3473         spin_lock_bh(&eth->dim_lock);
3474
3475         val = mtk_r32(eth, reg_map->pdma.delay_irq);
3476         val &= MTK_PDMA_DELAY_RX_MASK;
3477         val |= MTK_PDMA_DELAY_TX_EN;
3478
3479         cur = min_t(u32, DIV_ROUND_UP(cur_profile.usec, 20), MTK_PDMA_DELAY_PTIME_MASK);
3480         val |= cur << MTK_PDMA_DELAY_TX_PTIME_SHIFT;
3481
3482         cur = min_t(u32, cur_profile.pkts, MTK_PDMA_DELAY_PINT_MASK);
3483         val |= cur << MTK_PDMA_DELAY_TX_PINT_SHIFT;
3484
3485         mtk_w32(eth, val, reg_map->pdma.delay_irq);
3486         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
3487                 mtk_w32(eth, val, reg_map->qdma.delay_irq);
3488
3489         spin_unlock_bh(&eth->dim_lock);
3490
3491         dim->state = DIM_START_MEASURE;
3492 }
3493
3494 static void mtk_set_mcr_max_rx(struct mtk_mac *mac, u32 val)
3495 {
3496         struct mtk_eth *eth = mac->hw;
3497         u32 mcr_cur, mcr_new;
3498
3499         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
3500                 return;
3501
3502         mcr_cur = mtk_r32(mac->hw, MTK_MAC_MCR(mac->id));
3503         mcr_new = mcr_cur & ~MAC_MCR_MAX_RX_MASK;
3504
3505         if (val <= 1518)
3506                 mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1518);
3507         else if (val <= 1536)
3508                 mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1536);
3509         else if (val <= 1552)
3510                 mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_1552);
3511         else
3512                 mcr_new |= MAC_MCR_MAX_RX(MAC_MCR_MAX_RX_2048);
3513
3514         if (mcr_new != mcr_cur)
3515                 mtk_w32(mac->hw, mcr_new, MTK_MAC_MCR(mac->id));
3516 }
3517
3518 static void mtk_hw_reset(struct mtk_eth *eth)
3519 {
3520         u32 val;
3521
3522         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
3523                 regmap_write(eth->ethsys, ETHSYS_FE_RST_CHK_IDLE_EN, 0);
3524                 val = RSTCTRL_PPE0_V2;
3525         } else {
3526                 val = RSTCTRL_PPE0;
3527         }
3528
3529         if (MTK_HAS_CAPS(eth->soc->caps, MTK_RSTCTRL_PPE1))
3530                 val |= RSTCTRL_PPE1;
3531
3532         ethsys_reset(eth, RSTCTRL_ETH | RSTCTRL_FE | val);
3533
3534         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
3535                 regmap_write(eth->ethsys, ETHSYS_FE_RST_CHK_IDLE_EN,
3536                              0x3ffffff);
3537 }
3538
3539 static u32 mtk_hw_reset_read(struct mtk_eth *eth)
3540 {
3541         u32 val;
3542
3543         regmap_read(eth->ethsys, ETHSYS_RSTCTRL, &val);
3544         return val;
3545 }
3546
3547 static void mtk_hw_warm_reset(struct mtk_eth *eth)
3548 {
3549         u32 rst_mask, val;
3550
3551         regmap_update_bits(eth->ethsys, ETHSYS_RSTCTRL, RSTCTRL_FE,
3552                            RSTCTRL_FE);
3553         if (readx_poll_timeout_atomic(mtk_hw_reset_read, eth, val,
3554                                       val & RSTCTRL_FE, 1, 1000)) {
3555                 dev_err(eth->dev, "warm reset failed\n");
3556                 mtk_hw_reset(eth);
3557                 return;
3558         }
3559
3560         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
3561                 rst_mask = RSTCTRL_ETH | RSTCTRL_PPE0_V2;
3562         else
3563                 rst_mask = RSTCTRL_ETH | RSTCTRL_PPE0;
3564
3565         if (MTK_HAS_CAPS(eth->soc->caps, MTK_RSTCTRL_PPE1))
3566                 rst_mask |= RSTCTRL_PPE1;
3567
3568         regmap_update_bits(eth->ethsys, ETHSYS_RSTCTRL, rst_mask, rst_mask);
3569
3570         udelay(1);
3571         val = mtk_hw_reset_read(eth);
3572         if (!(val & rst_mask))
3573                 dev_err(eth->dev, "warm reset stage0 failed %08x (%08x)\n",
3574                         val, rst_mask);
3575
3576         rst_mask |= RSTCTRL_FE;
3577         regmap_update_bits(eth->ethsys, ETHSYS_RSTCTRL, rst_mask, ~rst_mask);
3578
3579         udelay(1);
3580         val = mtk_hw_reset_read(eth);
3581         if (val & rst_mask)
3582                 dev_err(eth->dev, "warm reset stage1 failed %08x (%08x)\n",
3583                         val, rst_mask);
3584 }
3585
3586 static bool mtk_hw_check_dma_hang(struct mtk_eth *eth)
3587 {
3588         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
3589         bool gmac1_tx, gmac2_tx, gdm1_tx, gdm2_tx;
3590         bool oq_hang, cdm1_busy, adma_busy;
3591         bool wtx_busy, cdm_full, oq_free;
3592         u32 wdidx, val, gdm1_fc, gdm2_fc;
3593         bool qfsm_hang, qfwd_hang;
3594         bool ret = false;
3595
3596         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
3597                 return false;
3598
3599         /* WDMA sanity checks */
3600         wdidx = mtk_r32(eth, reg_map->wdma_base[0] + 0xc);
3601
3602         val = mtk_r32(eth, reg_map->wdma_base[0] + 0x204);
3603         wtx_busy = FIELD_GET(MTK_TX_DMA_BUSY, val);
3604
3605         val = mtk_r32(eth, reg_map->wdma_base[0] + 0x230);
3606         cdm_full = !FIELD_GET(MTK_CDM_TXFIFO_RDY, val);
3607
3608         oq_free  = (!(mtk_r32(eth, reg_map->pse_oq_sta) & GENMASK(24, 16)) &&
3609                     !(mtk_r32(eth, reg_map->pse_oq_sta + 0x4) & GENMASK(8, 0)) &&
3610                     !(mtk_r32(eth, reg_map->pse_oq_sta + 0x10) & GENMASK(24, 16)));
3611
3612         if (wdidx == eth->reset.wdidx && wtx_busy && cdm_full && oq_free) {
3613                 if (++eth->reset.wdma_hang_count > 2) {
3614                         eth->reset.wdma_hang_count = 0;
3615                         ret = true;
3616                 }
3617                 goto out;
3618         }
3619
3620         /* QDMA sanity checks */
3621         qfsm_hang = !!mtk_r32(eth, reg_map->qdma.qtx_cfg + 0x234);
3622         qfwd_hang = !mtk_r32(eth, reg_map->qdma.qtx_cfg + 0x308);
3623
3624         gdm1_tx = FIELD_GET(GENMASK(31, 16), mtk_r32(eth, MTK_FE_GDM1_FSM)) > 0;
3625         gdm2_tx = FIELD_GET(GENMASK(31, 16), mtk_r32(eth, MTK_FE_GDM2_FSM)) > 0;
3626         gmac1_tx = FIELD_GET(GENMASK(31, 24), mtk_r32(eth, MTK_MAC_FSM(0))) != 1;
3627         gmac2_tx = FIELD_GET(GENMASK(31, 24), mtk_r32(eth, MTK_MAC_FSM(1))) != 1;
3628         gdm1_fc = mtk_r32(eth, reg_map->gdm1_cnt + 0x24);
3629         gdm2_fc = mtk_r32(eth, reg_map->gdm1_cnt + 0x64);
3630
3631         if (qfsm_hang && qfwd_hang &&
3632             ((gdm1_tx && gmac1_tx && gdm1_fc < 1) ||
3633              (gdm2_tx && gmac2_tx && gdm2_fc < 1))) {
3634                 if (++eth->reset.qdma_hang_count > 2) {
3635                         eth->reset.qdma_hang_count = 0;
3636                         ret = true;
3637                 }
3638                 goto out;
3639         }
3640
3641         /* ADMA sanity checks */
3642         oq_hang = !!(mtk_r32(eth, reg_map->pse_oq_sta) & GENMASK(8, 0));
3643         cdm1_busy = !!(mtk_r32(eth, MTK_FE_CDM1_FSM) & GENMASK(31, 16));
3644         adma_busy = !(mtk_r32(eth, reg_map->pdma.adma_rx_dbg0) & GENMASK(4, 0)) &&
3645                     !(mtk_r32(eth, reg_map->pdma.adma_rx_dbg0) & BIT(6));
3646
3647         if (oq_hang && cdm1_busy && adma_busy) {
3648                 if (++eth->reset.adma_hang_count > 2) {
3649                         eth->reset.adma_hang_count = 0;
3650                         ret = true;
3651                 }
3652                 goto out;
3653         }
3654
3655         eth->reset.wdma_hang_count = 0;
3656         eth->reset.qdma_hang_count = 0;
3657         eth->reset.adma_hang_count = 0;
3658 out:
3659         eth->reset.wdidx = wdidx;
3660
3661         return ret;
3662 }
3663
3664 static void mtk_hw_reset_monitor_work(struct work_struct *work)
3665 {
3666         struct delayed_work *del_work = to_delayed_work(work);
3667         struct mtk_eth *eth = container_of(del_work, struct mtk_eth,
3668                                            reset.monitor_work);
3669
3670         if (test_bit(MTK_RESETTING, &eth->state))
3671                 goto out;
3672
3673         /* DMA stuck checks */
3674         if (mtk_hw_check_dma_hang(eth))
3675                 schedule_work(&eth->pending_work);
3676
3677 out:
3678         schedule_delayed_work(&eth->reset.monitor_work,
3679                               MTK_DMA_MONITOR_TIMEOUT);
3680 }
3681
3682 static int mtk_hw_init(struct mtk_eth *eth, bool reset)
3683 {
3684         u32 dma_mask = ETHSYS_DMA_AG_MAP_PDMA | ETHSYS_DMA_AG_MAP_QDMA |
3685                        ETHSYS_DMA_AG_MAP_PPE;
3686         const struct mtk_reg_map *reg_map = eth->soc->reg_map;
3687         int i, val, ret;
3688
3689         if (!reset && test_and_set_bit(MTK_HW_INIT, &eth->state))
3690                 return 0;
3691
3692         if (!reset) {
3693                 pm_runtime_enable(eth->dev);
3694                 pm_runtime_get_sync(eth->dev);
3695
3696                 ret = mtk_clk_enable(eth);
3697                 if (ret)
3698                         goto err_disable_pm;
3699         }
3700
3701         if (eth->ethsys)
3702                 regmap_update_bits(eth->ethsys, ETHSYS_DMA_AG_MAP, dma_mask,
3703                                    of_dma_is_coherent(eth->dma_dev->of_node) * dma_mask);
3704
3705         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
3706                 ret = device_reset(eth->dev);
3707                 if (ret) {
3708                         dev_err(eth->dev, "MAC reset failed!\n");
3709                         goto err_disable_pm;
3710                 }
3711
3712                 /* set interrupt delays based on current Net DIM sample */
3713                 mtk_dim_rx(&eth->rx_dim.work);
3714                 mtk_dim_tx(&eth->tx_dim.work);
3715
3716                 /* disable delay and normal interrupt */
3717                 mtk_tx_irq_disable(eth, ~0);
3718                 mtk_rx_irq_disable(eth, ~0);
3719
3720                 return 0;
3721         }
3722
3723         msleep(100);
3724
3725         if (reset)
3726                 mtk_hw_warm_reset(eth);
3727         else
3728                 mtk_hw_reset(eth);
3729
3730         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
3731                 /* Set FE to PDMAv2 if necessary */
3732                 val = mtk_r32(eth, MTK_FE_GLO_MISC);
3733                 mtk_w32(eth,  val | BIT(4), MTK_FE_GLO_MISC);
3734         }
3735
3736         if (eth->pctl) {
3737                 /* Set GE2 driving and slew rate */
3738                 regmap_write(eth->pctl, GPIO_DRV_SEL10, 0xa00);
3739
3740                 /* set GE2 TDSEL */
3741                 regmap_write(eth->pctl, GPIO_OD33_CTRL8, 0x5);
3742
3743                 /* set GE2 TUNE */
3744                 regmap_write(eth->pctl, GPIO_BIAS_CTRL, 0x0);
3745         }
3746
3747         /* Set linkdown as the default for each GMAC. Its own MCR would be set
3748          * up with the more appropriate value when mtk_mac_config call is being
3749          * invoked.
3750          */
3751         for (i = 0; i < MTK_MAC_COUNT; i++) {
3752                 struct net_device *dev = eth->netdev[i];
3753
3754                 mtk_w32(eth, MAC_MCR_FORCE_LINK_DOWN, MTK_MAC_MCR(i));
3755                 if (dev) {
3756                         struct mtk_mac *mac = netdev_priv(dev);
3757
3758                         mtk_set_mcr_max_rx(mac, dev->mtu + MTK_RX_ETH_HLEN);
3759                 }
3760         }
3761
3762         /* Indicates CDM to parse the MTK special tag from CPU
3763          * which also is working out for untag packets.
3764          */
3765         val = mtk_r32(eth, MTK_CDMQ_IG_CTRL);
3766         mtk_w32(eth, val | MTK_CDMQ_STAG_EN, MTK_CDMQ_IG_CTRL);
3767         if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
3768                 val = mtk_r32(eth, MTK_CDMP_IG_CTRL);
3769                 mtk_w32(eth, val | MTK_CDMP_STAG_EN, MTK_CDMP_IG_CTRL);
3770
3771                 mtk_w32(eth, 1, MTK_CDMP_EG_CTRL);
3772         }
3773
3774         /* set interrupt delays based on current Net DIM sample */
3775         mtk_dim_rx(&eth->rx_dim.work);
3776         mtk_dim_tx(&eth->tx_dim.work);
3777
3778         /* disable delay and normal interrupt */
3779         mtk_tx_irq_disable(eth, ~0);
3780         mtk_rx_irq_disable(eth, ~0);
3781
3782         /* FE int grouping */
3783         mtk_w32(eth, MTK_TX_DONE_INT, reg_map->pdma.int_grp);
3784         mtk_w32(eth, eth->soc->txrx.rx_irq_done_mask, reg_map->pdma.int_grp + 4);
3785         mtk_w32(eth, MTK_TX_DONE_INT, reg_map->qdma.int_grp);
3786         mtk_w32(eth, eth->soc->txrx.rx_irq_done_mask, reg_map->qdma.int_grp + 4);
3787         mtk_w32(eth, 0x21021000, MTK_FE_INT_GRP);
3788
3789         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
3790                 /* PSE should not drop port8 and port9 packets from WDMA Tx */
3791                 mtk_w32(eth, 0x00000300, PSE_DROP_CFG);
3792
3793                 /* PSE should drop packets to port 8/9 on WDMA Rx ring full */
3794                 mtk_w32(eth, 0x00000300, PSE_PPE0_DROP);
3795
3796                 /* PSE Free Queue Flow Control  */
3797                 mtk_w32(eth, 0x01fa01f4, PSE_FQFC_CFG2);
3798
3799                 /* PSE config input queue threshold */
3800                 mtk_w32(eth, 0x001a000e, PSE_IQ_REV(1));
3801                 mtk_w32(eth, 0x01ff001a, PSE_IQ_REV(2));
3802                 mtk_w32(eth, 0x000e01ff, PSE_IQ_REV(3));
3803                 mtk_w32(eth, 0x000e000e, PSE_IQ_REV(4));
3804                 mtk_w32(eth, 0x000e000e, PSE_IQ_REV(5));
3805                 mtk_w32(eth, 0x000e000e, PSE_IQ_REV(6));
3806                 mtk_w32(eth, 0x000e000e, PSE_IQ_REV(7));
3807                 mtk_w32(eth, 0x000e000e, PSE_IQ_REV(8));
3808
3809                 /* PSE config output queue threshold */
3810                 mtk_w32(eth, 0x000f000a, PSE_OQ_TH(1));
3811                 mtk_w32(eth, 0x001a000f, PSE_OQ_TH(2));
3812                 mtk_w32(eth, 0x000f001a, PSE_OQ_TH(3));
3813                 mtk_w32(eth, 0x01ff000f, PSE_OQ_TH(4));
3814                 mtk_w32(eth, 0x000f000f, PSE_OQ_TH(5));
3815                 mtk_w32(eth, 0x0006000f, PSE_OQ_TH(6));
3816                 mtk_w32(eth, 0x00060006, PSE_OQ_TH(7));
3817                 mtk_w32(eth, 0x00060006, PSE_OQ_TH(8));
3818
3819                 /* GDM and CDM Threshold */
3820                 mtk_w32(eth, 0x00000004, MTK_GDM2_THRES);
3821                 mtk_w32(eth, 0x00000004, MTK_CDMW0_THRES);
3822                 mtk_w32(eth, 0x00000004, MTK_CDMW1_THRES);
3823                 mtk_w32(eth, 0x00000004, MTK_CDME0_THRES);
3824                 mtk_w32(eth, 0x00000004, MTK_CDME1_THRES);
3825                 mtk_w32(eth, 0x00000004, MTK_CDMM_THRES);
3826         }
3827
3828         return 0;
3829
3830 err_disable_pm:
3831         if (!reset) {
3832                 pm_runtime_put_sync(eth->dev);
3833                 pm_runtime_disable(eth->dev);
3834         }
3835
3836         return ret;
3837 }
3838
3839 static int mtk_hw_deinit(struct mtk_eth *eth)
3840 {
3841         if (!test_and_clear_bit(MTK_HW_INIT, &eth->state))
3842                 return 0;
3843
3844         mtk_clk_disable(eth);
3845
3846         pm_runtime_put_sync(eth->dev);
3847         pm_runtime_disable(eth->dev);
3848
3849         return 0;
3850 }
3851
3852 static int __init mtk_init(struct net_device *dev)
3853 {
3854         struct mtk_mac *mac = netdev_priv(dev);
3855         struct mtk_eth *eth = mac->hw;
3856         int ret;
3857
3858         ret = of_get_ethdev_address(mac->of_node, dev);
3859         if (ret) {
3860                 /* If the mac address is invalid, use random mac address */
3861                 eth_hw_addr_random(dev);
3862                 dev_err(eth->dev, "generated random MAC address %pM\n",
3863                         dev->dev_addr);
3864         }
3865
3866         return 0;
3867 }
3868
3869 static void mtk_uninit(struct net_device *dev)
3870 {
3871         struct mtk_mac *mac = netdev_priv(dev);
3872         struct mtk_eth *eth = mac->hw;
3873
3874         phylink_disconnect_phy(mac->phylink);
3875         mtk_tx_irq_disable(eth, ~0);
3876         mtk_rx_irq_disable(eth, ~0);
3877 }
3878
3879 static int mtk_change_mtu(struct net_device *dev, int new_mtu)
3880 {
3881         int length = new_mtu + MTK_RX_ETH_HLEN;
3882         struct mtk_mac *mac = netdev_priv(dev);
3883         struct mtk_eth *eth = mac->hw;
3884
3885         if (rcu_access_pointer(eth->prog) &&
3886             length > MTK_PP_MAX_BUF_SIZE) {
3887                 netdev_err(dev, "Invalid MTU for XDP mode\n");
3888                 return -EINVAL;
3889         }
3890
3891         mtk_set_mcr_max_rx(mac, length);
3892         dev->mtu = new_mtu;
3893
3894         return 0;
3895 }
3896
3897 static int mtk_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
3898 {
3899         struct mtk_mac *mac = netdev_priv(dev);
3900
3901         switch (cmd) {
3902         case SIOCGMIIPHY:
3903         case SIOCGMIIREG:
3904         case SIOCSMIIREG:
3905                 return phylink_mii_ioctl(mac->phylink, ifr, cmd);
3906         default:
3907                 break;
3908         }
3909
3910         return -EOPNOTSUPP;
3911 }
3912
3913 static void mtk_prepare_for_reset(struct mtk_eth *eth)
3914 {
3915         u32 val;
3916         int i;
3917
3918         /* disabe FE P3 and P4 */
3919         val = mtk_r32(eth, MTK_FE_GLO_CFG) | MTK_FE_LINK_DOWN_P3;
3920         if (MTK_HAS_CAPS(eth->soc->caps, MTK_RSTCTRL_PPE1))
3921                 val |= MTK_FE_LINK_DOWN_P4;
3922         mtk_w32(eth, val, MTK_FE_GLO_CFG);
3923
3924         /* adjust PPE configurations to prepare for reset */
3925         for (i = 0; i < ARRAY_SIZE(eth->ppe); i++)
3926                 mtk_ppe_prepare_reset(eth->ppe[i]);
3927
3928         /* disable NETSYS interrupts */
3929         mtk_w32(eth, 0, MTK_FE_INT_ENABLE);
3930
3931         /* force link down GMAC */
3932         for (i = 0; i < 2; i++) {
3933                 val = mtk_r32(eth, MTK_MAC_MCR(i)) & ~MAC_MCR_FORCE_LINK;
3934                 mtk_w32(eth, val, MTK_MAC_MCR(i));
3935         }
3936 }
3937
3938 static void mtk_pending_work(struct work_struct *work)
3939 {
3940         struct mtk_eth *eth = container_of(work, struct mtk_eth, pending_work);
3941         unsigned long restart = 0;
3942         u32 val;
3943         int i;
3944
3945         rtnl_lock();
3946         set_bit(MTK_RESETTING, &eth->state);
3947
3948         mtk_prepare_for_reset(eth);
3949         mtk_wed_fe_reset();
3950         /* Run again reset preliminary configuration in order to avoid any
3951          * possible race during FE reset since it can run releasing RTNL lock.
3952          */
3953         mtk_prepare_for_reset(eth);
3954
3955         /* stop all devices to make sure that dma is properly shut down */
3956         for (i = 0; i < MTK_MAC_COUNT; i++) {
3957                 if (!eth->netdev[i] || !netif_running(eth->netdev[i]))
3958                         continue;
3959
3960                 mtk_stop(eth->netdev[i]);
3961                 __set_bit(i, &restart);
3962         }
3963
3964         usleep_range(15000, 16000);
3965
3966         if (eth->dev->pins)
3967                 pinctrl_select_state(eth->dev->pins->p,
3968                                      eth->dev->pins->default_state);
3969         mtk_hw_init(eth, true);
3970
3971         /* restart DMA and enable IRQs */
3972         for (i = 0; i < MTK_MAC_COUNT; i++) {
3973                 if (!test_bit(i, &restart))
3974                         continue;
3975
3976                 if (mtk_open(eth->netdev[i])) {
3977                         netif_alert(eth, ifup, eth->netdev[i],
3978                                     "Driver up/down cycle failed\n");
3979                         dev_close(eth->netdev[i]);
3980                 }
3981         }
3982
3983         /* enabe FE P3 and P4 */
3984         val = mtk_r32(eth, MTK_FE_GLO_CFG) & ~MTK_FE_LINK_DOWN_P3;
3985         if (MTK_HAS_CAPS(eth->soc->caps, MTK_RSTCTRL_PPE1))
3986                 val &= ~MTK_FE_LINK_DOWN_P4;
3987         mtk_w32(eth, val, MTK_FE_GLO_CFG);
3988
3989         clear_bit(MTK_RESETTING, &eth->state);
3990
3991         mtk_wed_fe_reset_complete();
3992
3993         rtnl_unlock();
3994 }
3995
3996 static int mtk_free_dev(struct mtk_eth *eth)
3997 {
3998         int i;
3999
4000         for (i = 0; i < MTK_MAC_COUNT; i++) {
4001                 if (!eth->netdev[i])
4002                         continue;
4003                 free_netdev(eth->netdev[i]);
4004         }
4005
4006         for (i = 0; i < ARRAY_SIZE(eth->dsa_meta); i++) {
4007                 if (!eth->dsa_meta[i])
4008                         break;
4009                 metadata_dst_free(eth->dsa_meta[i]);
4010         }
4011
4012         return 0;
4013 }
4014
4015 static int mtk_unreg_dev(struct mtk_eth *eth)
4016 {
4017         int i;
4018
4019         for (i = 0; i < MTK_MAC_COUNT; i++) {
4020                 struct mtk_mac *mac;
4021                 if (!eth->netdev[i])
4022                         continue;
4023                 mac = netdev_priv(eth->netdev[i]);
4024                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
4025                         unregister_netdevice_notifier(&mac->device_notifier);
4026                 unregister_netdev(eth->netdev[i]);
4027         }
4028
4029         return 0;
4030 }
4031
4032 static int mtk_cleanup(struct mtk_eth *eth)
4033 {
4034         mtk_unreg_dev(eth);
4035         mtk_free_dev(eth);
4036         cancel_work_sync(&eth->pending_work);
4037         cancel_delayed_work_sync(&eth->reset.monitor_work);
4038
4039         return 0;
4040 }
4041
4042 static int mtk_get_link_ksettings(struct net_device *ndev,
4043                                   struct ethtool_link_ksettings *cmd)
4044 {
4045         struct mtk_mac *mac = netdev_priv(ndev);
4046
4047         if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
4048                 return -EBUSY;
4049
4050         return phylink_ethtool_ksettings_get(mac->phylink, cmd);
4051 }
4052
4053 static int mtk_set_link_ksettings(struct net_device *ndev,
4054                                   const struct ethtool_link_ksettings *cmd)
4055 {
4056         struct mtk_mac *mac = netdev_priv(ndev);
4057
4058         if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
4059                 return -EBUSY;
4060
4061         return phylink_ethtool_ksettings_set(mac->phylink, cmd);
4062 }
4063
4064 static void mtk_get_drvinfo(struct net_device *dev,
4065                             struct ethtool_drvinfo *info)
4066 {
4067         struct mtk_mac *mac = netdev_priv(dev);
4068
4069         strscpy(info->driver, mac->hw->dev->driver->name, sizeof(info->driver));
4070         strscpy(info->bus_info, dev_name(mac->hw->dev), sizeof(info->bus_info));
4071         info->n_stats = ARRAY_SIZE(mtk_ethtool_stats);
4072 }
4073
4074 static u32 mtk_get_msglevel(struct net_device *dev)
4075 {
4076         struct mtk_mac *mac = netdev_priv(dev);
4077
4078         return mac->hw->msg_enable;
4079 }
4080
4081 static void mtk_set_msglevel(struct net_device *dev, u32 value)
4082 {
4083         struct mtk_mac *mac = netdev_priv(dev);
4084
4085         mac->hw->msg_enable = value;
4086 }
4087
4088 static int mtk_nway_reset(struct net_device *dev)
4089 {
4090         struct mtk_mac *mac = netdev_priv(dev);
4091
4092         if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
4093                 return -EBUSY;
4094
4095         if (!mac->phylink)
4096                 return -ENOTSUPP;
4097
4098         return phylink_ethtool_nway_reset(mac->phylink);
4099 }
4100
4101 static void mtk_get_strings(struct net_device *dev, u32 stringset, u8 *data)
4102 {
4103         int i;
4104
4105         switch (stringset) {
4106         case ETH_SS_STATS: {
4107                 struct mtk_mac *mac = netdev_priv(dev);
4108
4109                 for (i = 0; i < ARRAY_SIZE(mtk_ethtool_stats); i++) {
4110                         memcpy(data, mtk_ethtool_stats[i].str, ETH_GSTRING_LEN);
4111                         data += ETH_GSTRING_LEN;
4112                 }
4113                 if (mtk_page_pool_enabled(mac->hw))
4114                         page_pool_ethtool_stats_get_strings(data);
4115                 break;
4116         }
4117         default:
4118                 break;
4119         }
4120 }
4121
4122 static int mtk_get_sset_count(struct net_device *dev, int sset)
4123 {
4124         switch (sset) {
4125         case ETH_SS_STATS: {
4126                 int count = ARRAY_SIZE(mtk_ethtool_stats);
4127                 struct mtk_mac *mac = netdev_priv(dev);
4128
4129                 if (mtk_page_pool_enabled(mac->hw))
4130                         count += page_pool_ethtool_stats_get_count();
4131                 return count;
4132         }
4133         default:
4134                 return -EOPNOTSUPP;
4135         }
4136 }
4137
4138 static void mtk_ethtool_pp_stats(struct mtk_eth *eth, u64 *data)
4139 {
4140         struct page_pool_stats stats = {};
4141         int i;
4142
4143         for (i = 0; i < ARRAY_SIZE(eth->rx_ring); i++) {
4144                 struct mtk_rx_ring *ring = &eth->rx_ring[i];
4145
4146                 if (!ring->page_pool)
4147                         continue;
4148
4149                 page_pool_get_stats(ring->page_pool, &stats);
4150         }
4151         page_pool_ethtool_stats_get(data, &stats);
4152 }
4153
4154 static void mtk_get_ethtool_stats(struct net_device *dev,
4155                                   struct ethtool_stats *stats, u64 *data)
4156 {
4157         struct mtk_mac *mac = netdev_priv(dev);
4158         struct mtk_hw_stats *hwstats = mac->hw_stats;
4159         u64 *data_src, *data_dst;
4160         unsigned int start;
4161         int i;
4162
4163         if (unlikely(test_bit(MTK_RESETTING, &mac->hw->state)))
4164                 return;
4165
4166         if (netif_running(dev) && netif_device_present(dev)) {
4167                 if (spin_trylock_bh(&hwstats->stats_lock)) {
4168                         mtk_stats_update_mac(mac);
4169                         spin_unlock_bh(&hwstats->stats_lock);
4170                 }
4171         }
4172
4173         data_src = (u64 *)hwstats;
4174
4175         do {
4176                 data_dst = data;
4177                 start = u64_stats_fetch_begin(&hwstats->syncp);
4178
4179                 for (i = 0; i < ARRAY_SIZE(mtk_ethtool_stats); i++)
4180                         *data_dst++ = *(data_src + mtk_ethtool_stats[i].offset);
4181                 if (mtk_page_pool_enabled(mac->hw))
4182                         mtk_ethtool_pp_stats(mac->hw, data_dst);
4183         } while (u64_stats_fetch_retry(&hwstats->syncp, start));
4184 }
4185
4186 static int mtk_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
4187                          u32 *rule_locs)
4188 {
4189         int ret = -EOPNOTSUPP;
4190
4191         switch (cmd->cmd) {
4192         case ETHTOOL_GRXRINGS:
4193                 if (dev->hw_features & NETIF_F_LRO) {
4194                         cmd->data = MTK_MAX_RX_RING_NUM;
4195                         ret = 0;
4196                 }
4197                 break;
4198         case ETHTOOL_GRXCLSRLCNT:
4199                 if (dev->hw_features & NETIF_F_LRO) {
4200                         struct mtk_mac *mac = netdev_priv(dev);
4201
4202                         cmd->rule_cnt = mac->hwlro_ip_cnt;
4203                         ret = 0;
4204                 }
4205                 break;
4206         case ETHTOOL_GRXCLSRULE:
4207                 if (dev->hw_features & NETIF_F_LRO)
4208                         ret = mtk_hwlro_get_fdir_entry(dev, cmd);
4209                 break;
4210         case ETHTOOL_GRXCLSRLALL:
4211                 if (dev->hw_features & NETIF_F_LRO)
4212                         ret = mtk_hwlro_get_fdir_all(dev, cmd,
4213                                                      rule_locs);
4214                 break;
4215         default:
4216                 break;
4217         }
4218
4219         return ret;
4220 }
4221
4222 static int mtk_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
4223 {
4224         int ret = -EOPNOTSUPP;
4225
4226         switch (cmd->cmd) {
4227         case ETHTOOL_SRXCLSRLINS:
4228                 if (dev->hw_features & NETIF_F_LRO)
4229                         ret = mtk_hwlro_add_ipaddr(dev, cmd);
4230                 break;
4231         case ETHTOOL_SRXCLSRLDEL:
4232                 if (dev->hw_features & NETIF_F_LRO)
4233                         ret = mtk_hwlro_del_ipaddr(dev, cmd);
4234                 break;
4235         default:
4236                 break;
4237         }
4238
4239         return ret;
4240 }
4241
4242 static u16 mtk_select_queue(struct net_device *dev, struct sk_buff *skb,
4243                             struct net_device *sb_dev)
4244 {
4245         struct mtk_mac *mac = netdev_priv(dev);
4246         unsigned int queue = 0;
4247
4248         if (netdev_uses_dsa(dev))
4249                 queue = skb_get_queue_mapping(skb) + 3;
4250         else
4251                 queue = mac->id;
4252
4253         if (queue >= dev->num_tx_queues)
4254                 queue = 0;
4255
4256         return queue;
4257 }
4258
4259 static const struct ethtool_ops mtk_ethtool_ops = {
4260         .get_link_ksettings     = mtk_get_link_ksettings,
4261         .set_link_ksettings     = mtk_set_link_ksettings,
4262         .get_drvinfo            = mtk_get_drvinfo,
4263         .get_msglevel           = mtk_get_msglevel,
4264         .set_msglevel           = mtk_set_msglevel,
4265         .nway_reset             = mtk_nway_reset,
4266         .get_link               = ethtool_op_get_link,
4267         .get_strings            = mtk_get_strings,
4268         .get_sset_count         = mtk_get_sset_count,
4269         .get_ethtool_stats      = mtk_get_ethtool_stats,
4270         .get_rxnfc              = mtk_get_rxnfc,
4271         .set_rxnfc              = mtk_set_rxnfc,
4272 };
4273
4274 static const struct net_device_ops mtk_netdev_ops = {
4275         .ndo_init               = mtk_init,
4276         .ndo_uninit             = mtk_uninit,
4277         .ndo_open               = mtk_open,
4278         .ndo_stop               = mtk_stop,
4279         .ndo_start_xmit         = mtk_start_xmit,
4280         .ndo_set_mac_address    = mtk_set_mac_address,
4281         .ndo_validate_addr      = eth_validate_addr,
4282         .ndo_eth_ioctl          = mtk_do_ioctl,
4283         .ndo_change_mtu         = mtk_change_mtu,
4284         .ndo_tx_timeout         = mtk_tx_timeout,
4285         .ndo_get_stats64        = mtk_get_stats64,
4286         .ndo_fix_features       = mtk_fix_features,
4287         .ndo_set_features       = mtk_set_features,
4288 #ifdef CONFIG_NET_POLL_CONTROLLER
4289         .ndo_poll_controller    = mtk_poll_controller,
4290 #endif
4291         .ndo_setup_tc           = mtk_eth_setup_tc,
4292         .ndo_bpf                = mtk_xdp,
4293         .ndo_xdp_xmit           = mtk_xdp_xmit,
4294         .ndo_select_queue       = mtk_select_queue,
4295 };
4296
4297 static int mtk_add_mac(struct mtk_eth *eth, struct device_node *np)
4298 {
4299         const __be32 *_id = of_get_property(np, "reg", NULL);
4300         phy_interface_t phy_mode;
4301         struct phylink *phylink;
4302         struct mtk_mac *mac;
4303         int id, err;
4304         int txqs = 1;
4305
4306         if (!_id) {
4307                 dev_err(eth->dev, "missing mac id\n");
4308                 return -EINVAL;
4309         }
4310
4311         id = be32_to_cpup(_id);
4312         if (id >= MTK_MAC_COUNT) {
4313                 dev_err(eth->dev, "%d is not a valid mac id\n", id);
4314                 return -EINVAL;
4315         }
4316
4317         if (eth->netdev[id]) {
4318                 dev_err(eth->dev, "duplicate mac id found: %d\n", id);
4319                 return -EINVAL;
4320         }
4321
4322         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA))
4323                 txqs = MTK_QDMA_NUM_QUEUES;
4324
4325         eth->netdev[id] = alloc_etherdev_mqs(sizeof(*mac), txqs, 1);
4326         if (!eth->netdev[id]) {
4327                 dev_err(eth->dev, "alloc_etherdev failed\n");
4328                 return -ENOMEM;
4329         }
4330         mac = netdev_priv(eth->netdev[id]);
4331         eth->mac[id] = mac;
4332         mac->id = id;
4333         mac->hw = eth;
4334         mac->of_node = np;
4335
4336         memset(mac->hwlro_ip, 0, sizeof(mac->hwlro_ip));
4337         mac->hwlro_ip_cnt = 0;
4338
4339         mac->hw_stats = devm_kzalloc(eth->dev,
4340                                      sizeof(*mac->hw_stats),
4341                                      GFP_KERNEL);
4342         if (!mac->hw_stats) {
4343                 dev_err(eth->dev, "failed to allocate counter memory\n");
4344                 err = -ENOMEM;
4345                 goto free_netdev;
4346         }
4347         spin_lock_init(&mac->hw_stats->stats_lock);
4348         u64_stats_init(&mac->hw_stats->syncp);
4349         mac->hw_stats->reg_offset = id * MTK_STAT_OFFSET;
4350
4351         /* phylink create */
4352         err = of_get_phy_mode(np, &phy_mode);
4353         if (err) {
4354                 dev_err(eth->dev, "incorrect phy-mode\n");
4355                 goto free_netdev;
4356         }
4357
4358         /* mac config is not set */
4359         mac->interface = PHY_INTERFACE_MODE_NA;
4360         mac->speed = SPEED_UNKNOWN;
4361
4362         mac->phylink_config.dev = &eth->netdev[id]->dev;
4363         mac->phylink_config.type = PHYLINK_NETDEV;
4364         /* This driver makes use of state->speed in mac_config */
4365         mac->phylink_config.legacy_pre_march2020 = true;
4366         mac->phylink_config.mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |
4367                 MAC_10 | MAC_100 | MAC_1000 | MAC_2500FD;
4368
4369         __set_bit(PHY_INTERFACE_MODE_MII,
4370                   mac->phylink_config.supported_interfaces);
4371         __set_bit(PHY_INTERFACE_MODE_GMII,
4372                   mac->phylink_config.supported_interfaces);
4373
4374         if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_RGMII))
4375                 phy_interface_set_rgmii(mac->phylink_config.supported_interfaces);
4376
4377         if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_TRGMII) && !mac->id)
4378                 __set_bit(PHY_INTERFACE_MODE_TRGMII,
4379                           mac->phylink_config.supported_interfaces);
4380
4381         if (MTK_HAS_CAPS(mac->hw->soc->caps, MTK_SGMII)) {
4382                 __set_bit(PHY_INTERFACE_MODE_SGMII,
4383                           mac->phylink_config.supported_interfaces);
4384                 __set_bit(PHY_INTERFACE_MODE_1000BASEX,
4385                           mac->phylink_config.supported_interfaces);
4386                 __set_bit(PHY_INTERFACE_MODE_2500BASEX,
4387                           mac->phylink_config.supported_interfaces);
4388         }
4389
4390         phylink = phylink_create(&mac->phylink_config,
4391                                  of_fwnode_handle(mac->of_node),
4392                                  phy_mode, &mtk_phylink_ops);
4393         if (IS_ERR(phylink)) {
4394                 err = PTR_ERR(phylink);
4395                 goto free_netdev;
4396         }
4397
4398         mac->phylink = phylink;
4399
4400         SET_NETDEV_DEV(eth->netdev[id], eth->dev);
4401         eth->netdev[id]->watchdog_timeo = 5 * HZ;
4402         eth->netdev[id]->netdev_ops = &mtk_netdev_ops;
4403         eth->netdev[id]->base_addr = (unsigned long)eth->base;
4404
4405         eth->netdev[id]->hw_features = eth->soc->hw_features;
4406         if (eth->hwlro)
4407                 eth->netdev[id]->hw_features |= NETIF_F_LRO;
4408
4409         eth->netdev[id]->vlan_features = eth->soc->hw_features &
4410                 ~NETIF_F_HW_VLAN_CTAG_TX;
4411         eth->netdev[id]->features |= eth->soc->hw_features;
4412         eth->netdev[id]->ethtool_ops = &mtk_ethtool_ops;
4413
4414         eth->netdev[id]->irq = eth->irq[0];
4415         eth->netdev[id]->dev.of_node = np;
4416
4417         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
4418                 eth->netdev[id]->max_mtu = MTK_MAX_RX_LENGTH - MTK_RX_ETH_HLEN;
4419         else
4420                 eth->netdev[id]->max_mtu = MTK_MAX_RX_LENGTH_2K - MTK_RX_ETH_HLEN;
4421
4422         if (MTK_HAS_CAPS(eth->soc->caps, MTK_QDMA)) {
4423                 mac->device_notifier.notifier_call = mtk_device_event;
4424                 register_netdevice_notifier(&mac->device_notifier);
4425         }
4426
4427         if (mtk_page_pool_enabled(eth))
4428                 eth->netdev[id]->xdp_features = NETDEV_XDP_ACT_BASIC |
4429                                                 NETDEV_XDP_ACT_REDIRECT |
4430                                                 NETDEV_XDP_ACT_NDO_XMIT |
4431                                                 NETDEV_XDP_ACT_NDO_XMIT_SG;
4432
4433         return 0;
4434
4435 free_netdev:
4436         free_netdev(eth->netdev[id]);
4437         return err;
4438 }
4439
4440 void mtk_eth_set_dma_device(struct mtk_eth *eth, struct device *dma_dev)
4441 {
4442         struct net_device *dev, *tmp;
4443         LIST_HEAD(dev_list);
4444         int i;
4445
4446         rtnl_lock();
4447
4448         for (i = 0; i < MTK_MAC_COUNT; i++) {
4449                 dev = eth->netdev[i];
4450
4451                 if (!dev || !(dev->flags & IFF_UP))
4452                         continue;
4453
4454                 list_add_tail(&dev->close_list, &dev_list);
4455         }
4456
4457         dev_close_many(&dev_list, false);
4458
4459         eth->dma_dev = dma_dev;
4460
4461         list_for_each_entry_safe(dev, tmp, &dev_list, close_list) {
4462                 list_del_init(&dev->close_list);
4463                 dev_open(dev, NULL);
4464         }
4465
4466         rtnl_unlock();
4467 }
4468
4469 static int mtk_probe(struct platform_device *pdev)
4470 {
4471         struct resource *res = NULL;
4472         struct device_node *mac_np;
4473         struct mtk_eth *eth;
4474         int err, i;
4475
4476         eth = devm_kzalloc(&pdev->dev, sizeof(*eth), GFP_KERNEL);
4477         if (!eth)
4478                 return -ENOMEM;
4479
4480         eth->soc = of_device_get_match_data(&pdev->dev);
4481
4482         eth->dev = &pdev->dev;
4483         eth->dma_dev = &pdev->dev;
4484         eth->base = devm_platform_ioremap_resource(pdev, 0);
4485         if (IS_ERR(eth->base))
4486                 return PTR_ERR(eth->base);
4487
4488         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628))
4489                 eth->ip_align = NET_IP_ALIGN;
4490
4491         spin_lock_init(&eth->page_lock);
4492         spin_lock_init(&eth->tx_irq_lock);
4493         spin_lock_init(&eth->rx_irq_lock);
4494         spin_lock_init(&eth->dim_lock);
4495
4496         eth->rx_dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE;
4497         INIT_WORK(&eth->rx_dim.work, mtk_dim_rx);
4498         INIT_DELAYED_WORK(&eth->reset.monitor_work, mtk_hw_reset_monitor_work);
4499
4500         eth->tx_dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE;
4501         INIT_WORK(&eth->tx_dim.work, mtk_dim_tx);
4502
4503         if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
4504                 eth->ethsys = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
4505                                                               "mediatek,ethsys");
4506                 if (IS_ERR(eth->ethsys)) {
4507                         dev_err(&pdev->dev, "no ethsys regmap found\n");
4508                         return PTR_ERR(eth->ethsys);
4509                 }
4510         }
4511
4512         if (MTK_HAS_CAPS(eth->soc->caps, MTK_INFRA)) {
4513                 eth->infra = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
4514                                                              "mediatek,infracfg");
4515                 if (IS_ERR(eth->infra)) {
4516                         dev_err(&pdev->dev, "no infracfg regmap found\n");
4517                         return PTR_ERR(eth->infra);
4518                 }
4519         }
4520
4521         if (of_dma_is_coherent(pdev->dev.of_node)) {
4522                 struct regmap *cci;
4523
4524                 cci = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
4525                                                       "cci-control-port");
4526                 /* enable CPU/bus coherency */
4527                 if (!IS_ERR(cci))
4528                         regmap_write(cci, 0, 3);
4529         }
4530
4531         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SGMII)) {
4532                 eth->sgmii = devm_kzalloc(eth->dev, sizeof(*eth->sgmii),
4533                                           GFP_KERNEL);
4534                 if (!eth->sgmii)
4535                         return -ENOMEM;
4536
4537                 err = mtk_sgmii_init(eth->sgmii, pdev->dev.of_node,
4538                                      eth->soc->ana_rgc3);
4539
4540                 if (err)
4541                         return err;
4542         }
4543
4544         if (eth->soc->required_pctl) {
4545                 eth->pctl = syscon_regmap_lookup_by_phandle(pdev->dev.of_node,
4546                                                             "mediatek,pctl");
4547                 if (IS_ERR(eth->pctl)) {
4548                         dev_err(&pdev->dev, "no pctl regmap found\n");
4549                         return PTR_ERR(eth->pctl);
4550                 }
4551         }
4552
4553         if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
4554                 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
4555                 if (!res)
4556                         return -EINVAL;
4557         }
4558
4559         if (eth->soc->offload_version) {
4560                 for (i = 0;; i++) {
4561                         struct device_node *np;
4562                         phys_addr_t wdma_phy;
4563                         u32 wdma_base;
4564
4565                         if (i >= ARRAY_SIZE(eth->soc->reg_map->wdma_base))
4566                                 break;
4567
4568                         np = of_parse_phandle(pdev->dev.of_node,
4569                                               "mediatek,wed", i);
4570                         if (!np)
4571                                 break;
4572
4573                         wdma_base = eth->soc->reg_map->wdma_base[i];
4574                         wdma_phy = res ? res->start + wdma_base : 0;
4575                         mtk_wed_add_hw(np, eth, eth->base + wdma_base,
4576                                        wdma_phy, i);
4577                 }
4578         }
4579
4580         for (i = 0; i < 3; i++) {
4581                 if (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_INT) && i > 0)
4582                         eth->irq[i] = eth->irq[0];
4583                 else
4584                         eth->irq[i] = platform_get_irq(pdev, i);
4585                 if (eth->irq[i] < 0) {
4586                         dev_err(&pdev->dev, "no IRQ%d resource found\n", i);
4587                         err = -ENXIO;
4588                         goto err_wed_exit;
4589                 }
4590         }
4591         for (i = 0; i < ARRAY_SIZE(eth->clks); i++) {
4592                 eth->clks[i] = devm_clk_get(eth->dev,
4593                                             mtk_clks_source_name[i]);
4594                 if (IS_ERR(eth->clks[i])) {
4595                         if (PTR_ERR(eth->clks[i]) == -EPROBE_DEFER) {
4596                                 err = -EPROBE_DEFER;
4597                                 goto err_wed_exit;
4598                         }
4599                         if (eth->soc->required_clks & BIT(i)) {
4600                                 dev_err(&pdev->dev, "clock %s not found\n",
4601                                         mtk_clks_source_name[i]);
4602                                 err = -EINVAL;
4603                                 goto err_wed_exit;
4604                         }
4605                         eth->clks[i] = NULL;
4606                 }
4607         }
4608
4609         eth->msg_enable = netif_msg_init(mtk_msg_level, MTK_DEFAULT_MSG_ENABLE);
4610         INIT_WORK(&eth->pending_work, mtk_pending_work);
4611
4612         err = mtk_hw_init(eth, false);
4613         if (err)
4614                 goto err_wed_exit;
4615
4616         eth->hwlro = MTK_HAS_CAPS(eth->soc->caps, MTK_HWLRO);
4617
4618         for_each_child_of_node(pdev->dev.of_node, mac_np) {
4619                 if (!of_device_is_compatible(mac_np,
4620                                              "mediatek,eth-mac"))
4621                         continue;
4622
4623                 if (!of_device_is_available(mac_np))
4624                         continue;
4625
4626                 err = mtk_add_mac(eth, mac_np);
4627                 if (err) {
4628                         of_node_put(mac_np);
4629                         goto err_deinit_hw;
4630                 }
4631         }
4632
4633         if (MTK_HAS_CAPS(eth->soc->caps, MTK_SHARED_INT)) {
4634                 err = devm_request_irq(eth->dev, eth->irq[0],
4635                                        mtk_handle_irq, 0,
4636                                        dev_name(eth->dev), eth);
4637         } else {
4638                 err = devm_request_irq(eth->dev, eth->irq[1],
4639                                        mtk_handle_irq_tx, 0,
4640                                        dev_name(eth->dev), eth);
4641                 if (err)
4642                         goto err_free_dev;
4643
4644                 err = devm_request_irq(eth->dev, eth->irq[2],
4645                                        mtk_handle_irq_rx, 0,
4646                                        dev_name(eth->dev), eth);
4647         }
4648         if (err)
4649                 goto err_free_dev;
4650
4651         /* No MT7628/88 support yet */
4652         if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628)) {
4653                 err = mtk_mdio_init(eth);
4654                 if (err)
4655                         goto err_free_dev;
4656         }
4657
4658         if (eth->soc->offload_version) {
4659                 u32 num_ppe;
4660
4661                 num_ppe = MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2) ? 2 : 1;
4662                 num_ppe = min_t(u32, ARRAY_SIZE(eth->ppe), num_ppe);
4663                 for (i = 0; i < num_ppe; i++) {
4664                         u32 ppe_addr = eth->soc->reg_map->ppe_base + i * 0x400;
4665
4666                         eth->ppe[i] = mtk_ppe_init(eth, eth->base + ppe_addr,
4667                                                    eth->soc->offload_version, i);
4668                         if (!eth->ppe[i]) {
4669                                 err = -ENOMEM;
4670                                 goto err_deinit_ppe;
4671                         }
4672                 }
4673
4674                 err = mtk_eth_offload_init(eth);
4675                 if (err)
4676                         goto err_deinit_ppe;
4677         }
4678
4679         for (i = 0; i < MTK_MAX_DEVS; i++) {
4680                 if (!eth->netdev[i])
4681                         continue;
4682
4683                 err = register_netdev(eth->netdev[i]);
4684                 if (err) {
4685                         dev_err(eth->dev, "error bringing up device\n");
4686                         goto err_deinit_ppe;
4687                 } else
4688                         netif_info(eth, probe, eth->netdev[i],
4689                                    "mediatek frame engine at 0x%08lx, irq %d\n",
4690                                    eth->netdev[i]->base_addr, eth->irq[0]);
4691         }
4692
4693         /* we run 2 devices on the same DMA ring so we need a dummy device
4694          * for NAPI to work
4695          */
4696         init_dummy_netdev(&eth->dummy_dev);
4697         netif_napi_add(&eth->dummy_dev, &eth->tx_napi, mtk_napi_tx);
4698         netif_napi_add(&eth->dummy_dev, &eth->rx_napi, mtk_napi_rx);
4699
4700         platform_set_drvdata(pdev, eth);
4701         schedule_delayed_work(&eth->reset.monitor_work,
4702                               MTK_DMA_MONITOR_TIMEOUT);
4703
4704         return 0;
4705
4706 err_deinit_ppe:
4707         mtk_ppe_deinit(eth);
4708         mtk_mdio_cleanup(eth);
4709 err_free_dev:
4710         mtk_free_dev(eth);
4711 err_deinit_hw:
4712         mtk_hw_deinit(eth);
4713 err_wed_exit:
4714         mtk_wed_exit();
4715
4716         return err;
4717 }
4718
4719 static int mtk_remove(struct platform_device *pdev)
4720 {
4721         struct mtk_eth *eth = platform_get_drvdata(pdev);
4722         struct mtk_mac *mac;
4723         int i;
4724
4725         /* stop all devices to make sure that dma is properly shut down */
4726         for (i = 0; i < MTK_MAC_COUNT; i++) {
4727                 if (!eth->netdev[i])
4728                         continue;
4729                 mtk_stop(eth->netdev[i]);
4730                 mac = netdev_priv(eth->netdev[i]);
4731                 phylink_disconnect_phy(mac->phylink);
4732         }
4733
4734         mtk_wed_exit();
4735         mtk_hw_deinit(eth);
4736
4737         netif_napi_del(&eth->tx_napi);
4738         netif_napi_del(&eth->rx_napi);
4739         mtk_cleanup(eth);
4740         mtk_mdio_cleanup(eth);
4741
4742         return 0;
4743 }
4744
4745 static const struct mtk_soc_data mt2701_data = {
4746         .reg_map = &mtk_reg_map,
4747         .caps = MT7623_CAPS | MTK_HWLRO,
4748         .hw_features = MTK_HW_FEATURES,
4749         .required_clks = MT7623_CLKS_BITMAP,
4750         .required_pctl = true,
4751         .txrx = {
4752                 .txd_size = sizeof(struct mtk_tx_dma),
4753                 .rxd_size = sizeof(struct mtk_rx_dma),
4754                 .rx_irq_done_mask = MTK_RX_DONE_INT,
4755                 .rx_dma_l4_valid = RX_DMA_L4_VALID,
4756                 .dma_max_len = MTK_TX_DMA_BUF_LEN,
4757                 .dma_len_offset = 16,
4758         },
4759 };
4760
4761 static const struct mtk_soc_data mt7621_data = {
4762         .reg_map = &mtk_reg_map,
4763         .caps = MT7621_CAPS,
4764         .hw_features = MTK_HW_FEATURES,
4765         .required_clks = MT7621_CLKS_BITMAP,
4766         .required_pctl = false,
4767         .offload_version = 1,
4768         .hash_offset = 2,
4769         .foe_entry_size = sizeof(struct mtk_foe_entry) - 16,
4770         .txrx = {
4771                 .txd_size = sizeof(struct mtk_tx_dma),
4772                 .rxd_size = sizeof(struct mtk_rx_dma),
4773                 .rx_irq_done_mask = MTK_RX_DONE_INT,
4774                 .rx_dma_l4_valid = RX_DMA_L4_VALID,
4775                 .dma_max_len = MTK_TX_DMA_BUF_LEN,
4776                 .dma_len_offset = 16,
4777         },
4778 };
4779
4780 static const struct mtk_soc_data mt7622_data = {
4781         .reg_map = &mtk_reg_map,
4782         .ana_rgc3 = 0x2028,
4783         .caps = MT7622_CAPS | MTK_HWLRO,
4784         .hw_features = MTK_HW_FEATURES,
4785         .required_clks = MT7622_CLKS_BITMAP,
4786         .required_pctl = false,
4787         .offload_version = 2,
4788         .hash_offset = 2,
4789         .foe_entry_size = sizeof(struct mtk_foe_entry) - 16,
4790         .txrx = {
4791                 .txd_size = sizeof(struct mtk_tx_dma),
4792                 .rxd_size = sizeof(struct mtk_rx_dma),
4793                 .rx_irq_done_mask = MTK_RX_DONE_INT,
4794                 .rx_dma_l4_valid = RX_DMA_L4_VALID,
4795                 .dma_max_len = MTK_TX_DMA_BUF_LEN,
4796                 .dma_len_offset = 16,
4797         },
4798 };
4799
4800 static const struct mtk_soc_data mt7623_data = {
4801         .reg_map = &mtk_reg_map,
4802         .caps = MT7623_CAPS | MTK_HWLRO,
4803         .hw_features = MTK_HW_FEATURES,
4804         .required_clks = MT7623_CLKS_BITMAP,
4805         .required_pctl = true,
4806         .offload_version = 1,
4807         .hash_offset = 2,
4808         .foe_entry_size = sizeof(struct mtk_foe_entry) - 16,
4809         .txrx = {
4810                 .txd_size = sizeof(struct mtk_tx_dma),
4811                 .rxd_size = sizeof(struct mtk_rx_dma),
4812                 .rx_irq_done_mask = MTK_RX_DONE_INT,
4813                 .rx_dma_l4_valid = RX_DMA_L4_VALID,
4814                 .dma_max_len = MTK_TX_DMA_BUF_LEN,
4815                 .dma_len_offset = 16,
4816         },
4817 };
4818
4819 static const struct mtk_soc_data mt7629_data = {
4820         .reg_map = &mtk_reg_map,
4821         .ana_rgc3 = 0x128,
4822         .caps = MT7629_CAPS | MTK_HWLRO,
4823         .hw_features = MTK_HW_FEATURES,
4824         .required_clks = MT7629_CLKS_BITMAP,
4825         .required_pctl = false,
4826         .txrx = {
4827                 .txd_size = sizeof(struct mtk_tx_dma),
4828                 .rxd_size = sizeof(struct mtk_rx_dma),
4829                 .rx_irq_done_mask = MTK_RX_DONE_INT,
4830                 .rx_dma_l4_valid = RX_DMA_L4_VALID,
4831                 .dma_max_len = MTK_TX_DMA_BUF_LEN,
4832                 .dma_len_offset = 16,
4833         },
4834 };
4835
4836 static const struct mtk_soc_data mt7986_data = {
4837         .reg_map = &mt7986_reg_map,
4838         .ana_rgc3 = 0x128,
4839         .caps = MT7986_CAPS,
4840         .hw_features = MTK_HW_FEATURES,
4841         .required_clks = MT7986_CLKS_BITMAP,
4842         .required_pctl = false,
4843         .offload_version = 2,
4844         .hash_offset = 4,
4845         .foe_entry_size = sizeof(struct mtk_foe_entry),
4846         .txrx = {
4847                 .txd_size = sizeof(struct mtk_tx_dma_v2),
4848                 .rxd_size = sizeof(struct mtk_rx_dma_v2),
4849                 .rx_irq_done_mask = MTK_RX_DONE_INT_V2,
4850                 .rx_dma_l4_valid = RX_DMA_L4_VALID_V2,
4851                 .dma_max_len = MTK_TX_DMA_BUF_LEN_V2,
4852                 .dma_len_offset = 8,
4853         },
4854 };
4855
4856 static const struct mtk_soc_data rt5350_data = {
4857         .reg_map = &mt7628_reg_map,
4858         .caps = MT7628_CAPS,
4859         .hw_features = MTK_HW_FEATURES_MT7628,
4860         .required_clks = MT7628_CLKS_BITMAP,
4861         .required_pctl = false,
4862         .txrx = {
4863                 .txd_size = sizeof(struct mtk_tx_dma),
4864                 .rxd_size = sizeof(struct mtk_rx_dma),
4865                 .rx_irq_done_mask = MTK_RX_DONE_INT,
4866                 .rx_dma_l4_valid = RX_DMA_L4_VALID_PDMA,
4867                 .dma_max_len = MTK_TX_DMA_BUF_LEN,
4868                 .dma_len_offset = 16,
4869         },
4870 };
4871
4872 const struct of_device_id of_mtk_match[] = {
4873         { .compatible = "mediatek,mt2701-eth", .data = &mt2701_data},
4874         { .compatible = "mediatek,mt7621-eth", .data = &mt7621_data},
4875         { .compatible = "mediatek,mt7622-eth", .data = &mt7622_data},
4876         { .compatible = "mediatek,mt7623-eth", .data = &mt7623_data},
4877         { .compatible = "mediatek,mt7629-eth", .data = &mt7629_data},
4878         { .compatible = "mediatek,mt7986-eth", .data = &mt7986_data},
4879         { .compatible = "ralink,rt5350-eth", .data = &rt5350_data},
4880         {},
4881 };
4882 MODULE_DEVICE_TABLE(of, of_mtk_match);
4883
4884 static struct platform_driver mtk_driver = {
4885         .probe = mtk_probe,
4886         .remove = mtk_remove,
4887         .driver = {
4888                 .name = "mtk_soc_eth",
4889                 .of_match_table = of_mtk_match,
4890         },
4891 };
4892
4893 module_platform_driver(mtk_driver);
4894
4895 MODULE_LICENSE("GPL");
4896 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
4897 MODULE_DESCRIPTION("Ethernet driver for MediaTek SoC");