FIELD_PREP(MTK_QTX_SCH_MIN_RATE_MAN, 1) |
              FIELD_PREP(MTK_QTX_SCH_MIN_RATE_EXP, 4) |
              MTK_QTX_SCH_LEAKY_BUCKET_SIZE;
-       if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v1(eth))
                val |= MTK_QTX_SCH_LEAKY_BUCKET_EN;
 
        if (IS_ENABLED(CONFIG_SOC_MT7621)) {
        rxd->rxd1 = READ_ONCE(dma_rxd->rxd1);
        rxd->rxd3 = READ_ONCE(dma_rxd->rxd3);
        rxd->rxd4 = READ_ONCE(dma_rxd->rxd4);
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                rxd->rxd5 = READ_ONCE(dma_rxd->rxd5);
                rxd->rxd6 = READ_ONCE(dma_rxd->rxd6);
        }
 
                txd->txd3 = TX_DMA_PLEN0(MTK_QDMA_PAGE_SIZE);
                txd->txd4 = 0;
-               if (MTK_HAS_CAPS(soc->caps, MTK_NETSYS_V2)) {
+               if (mtk_is_netsys_v2_or_greater(eth)) {
                        txd->txd5 = 0;
                        txd->txd6 = 0;
                        txd->txd7 = 0;
        struct mtk_mac *mac = netdev_priv(dev);
        struct mtk_eth *eth = mac->hw;
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                mtk_tx_set_dma_desc_v2(dev, txd, info);
        else
                mtk_tx_set_dma_desc_v1(dev, txd, info);
 
 static bool mtk_page_pool_enabled(struct mtk_eth *eth)
 {
-       return MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2);
+       return eth->soc->version == 2;
 }
 
 static struct page_pool *mtk_create_page_pool(struct mtk_eth *eth,
                        break;
 
                /* find out which mac the packet come from. values start at 1 */
-               if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+               if (mtk_is_netsys_v2_or_greater(eth))
                        mac = RX_DMA_GET_SPORT_V2(trxd.rxd5) - 1;
                else if (!MTK_HAS_CAPS(eth->soc->caps, MTK_SOC_MT7628) &&
                         !(trxd.rxd4 & RX_DMA_SPECIAL_TAG))
                skb->dev = netdev;
                bytes += skb->len;
 
-               if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+               if (mtk_is_netsys_v2_or_greater(eth)) {
                        reason = FIELD_GET(MTK_RXD5_PPE_CPU_REASON, trxd.rxd5);
                        hash = trxd.rxd5 & MTK_RXD5_FOE_ENTRY;
                        if (hash != MTK_RXD5_FOE_ENTRY)
                /* When using VLAN untagging in combination with DSA, the
                 * hardware treats the MTK special tag as a VLAN and untags it.
                 */
-               if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2) &&
-                   (trxd.rxd2 & RX_DMA_VTAG) && netdev_uses_dsa(netdev)) {
+               if (mtk_is_netsys_v1(eth) && (trxd.rxd2 & RX_DMA_VTAG) &&
+                   netdev_uses_dsa(netdev)) {
                        unsigned int port = RX_DMA_VPID(trxd.rxd3) & GENMASK(2, 0);
 
                        if (port < ARRAY_SIZE(eth->dsa_meta) &&
                txd->txd2 = next_ptr;
                txd->txd3 = TX_DMA_LS0 | TX_DMA_OWNER_CPU;
                txd->txd4 = 0;
-               if (MTK_HAS_CAPS(soc->caps, MTK_NETSYS_V2)) {
+               if (mtk_is_netsys_v2_or_greater(eth)) {
                        txd->txd5 = 0;
                        txd->txd6 = 0;
                        txd->txd7 = 0;
                              FIELD_PREP(MTK_QTX_SCH_MIN_RATE_MAN, 1) |
                              FIELD_PREP(MTK_QTX_SCH_MIN_RATE_EXP, 4) |
                              MTK_QTX_SCH_LEAKY_BUCKET_SIZE;
-                       if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+                       if (mtk_is_netsys_v1(eth))
                                val |= MTK_QTX_SCH_LEAKY_BUCKET_EN;
                        mtk_w32(eth, val, soc->reg_map->qdma.qtx_sch + ofs);
                        ofs += MTK_QTX_OFFSET;
                }
                val = MTK_QDMA_TX_SCH_MAX_WFQ | (MTK_QDMA_TX_SCH_MAX_WFQ << 16);
                mtk_w32(eth, val, soc->reg_map->qdma.tx_sch_rate);
-               if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+               if (mtk_is_netsys_v2_or_greater(eth))
                        mtk_w32(eth, val, soc->reg_map->qdma.tx_sch_rate + 4);
        } else {
                mtk_w32(eth, ring->phys_pdma, MT7628_TX_BASE_PTR0);
 
                rxd->rxd3 = 0;
                rxd->rxd4 = 0;
-               if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+               if (mtk_is_netsys_v2_or_greater(eth)) {
                        rxd->rxd5 = 0;
                        rxd->rxd6 = 0;
                        rxd->rxd7 = 0;
                       MTK_TX_BT_32DWORDS | MTK_NDP_CO_PRO |
                       MTK_RX_2B_OFFSET | MTK_TX_WB_DDONE;
 
-               if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+               if (mtk_is_netsys_v2_or_greater(eth))
                        val |= MTK_MUTLI_CNT | MTK_RESV_BUF |
                               MTK_WCOMP_EN | MTK_DMAD_WR_WDONE |
                               MTK_CHK_DDONE_EN | MTK_LEAKY_BUCKET_EN;
        phylink_start(mac->phylink);
        netif_tx_start_all_queues(dev);
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return 0;
 
        if (mtk_uses_dsa(dev) && !eth->prog) {
 {
        u32 val;
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                regmap_write(eth->ethsys, ETHSYS_FE_RST_CHK_IDLE_EN, 0);
                val = RSTCTRL_PPE0_V2;
        } else {
 
        ethsys_reset(eth, RSTCTRL_ETH | RSTCTRL_FE | val);
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                regmap_write(eth->ethsys, ETHSYS_FE_RST_CHK_IDLE_EN,
                             0x3ffffff);
 }
                return;
        }
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                rst_mask = RSTCTRL_ETH | RSTCTRL_PPE0_V2;
        else
                rst_mask = RSTCTRL_ETH | RSTCTRL_PPE0;
        else
                mtk_hw_reset(eth);
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                /* Set FE to PDMAv2 if necessary */
                val = mtk_r32(eth, MTK_FE_GLO_MISC);
                mtk_w32(eth,  val | BIT(4), MTK_FE_GLO_MISC);
         */
        val = mtk_r32(eth, MTK_CDMQ_IG_CTRL);
        mtk_w32(eth, val | MTK_CDMQ_STAG_EN, MTK_CDMQ_IG_CTRL);
-       if (!MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v1(eth)) {
                val = mtk_r32(eth, MTK_CDMP_IG_CTRL);
                mtk_w32(eth, val | MTK_CDMP_STAG_EN, MTK_CDMP_IG_CTRL);
 
        mtk_w32(eth, eth->soc->txrx.rx_irq_done_mask, reg_map->qdma.int_grp + 4);
        mtk_w32(eth, 0x21021000, MTK_FE_INT_GRP);
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                /* PSE should not drop port8 and port9 packets from WDMA Tx */
                mtk_w32(eth, 0x00000300, PSE_DROP_CFG);
 
                }
        }
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
                if (!res) {
                        err = -EINVAL;
        }
 
        if (eth->soc->offload_version) {
-               u32 num_ppe;
+               u32 num_ppe = mtk_is_netsys_v2_or_greater(eth) ? 2 : 1;
 
-               num_ppe = MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2) ? 2 : 1;
                num_ppe = min_t(u32, ARRAY_SIZE(eth->ppe), num_ppe);
                for (i = 0; i < num_ppe; i++) {
                        u32 ppe_addr = eth->soc->reg_map->ppe_base + i * 0x400;
        .hw_features = MTK_HW_FEATURES,
        .required_clks = MT7623_CLKS_BITMAP,
        .required_pctl = true,
+       .version = 1,
        .txrx = {
                .txd_size = sizeof(struct mtk_tx_dma),
                .rxd_size = sizeof(struct mtk_rx_dma),
        .hw_features = MTK_HW_FEATURES,
        .required_clks = MT7621_CLKS_BITMAP,
        .required_pctl = false,
+       .version = 1,
        .offload_version = 1,
        .hash_offset = 2,
        .foe_entry_size = MTK_FOE_ENTRY_V1_SIZE,
        .hw_features = MTK_HW_FEATURES,
        .required_clks = MT7622_CLKS_BITMAP,
        .required_pctl = false,
+       .version = 1,
        .offload_version = 2,
        .hash_offset = 2,
        .has_accounting = true,
        .hw_features = MTK_HW_FEATURES,
        .required_clks = MT7623_CLKS_BITMAP,
        .required_pctl = true,
+       .version = 1,
        .offload_version = 1,
        .hash_offset = 2,
        .foe_entry_size = MTK_FOE_ENTRY_V1_SIZE,
        .required_clks = MT7629_CLKS_BITMAP,
        .required_pctl = false,
        .has_accounting = true,
+       .version = 1,
        .txrx = {
                .txd_size = sizeof(struct mtk_tx_dma),
                .rxd_size = sizeof(struct mtk_rx_dma),
        .hw_features = MTK_HW_FEATURES,
        .required_clks = MT7981_CLKS_BITMAP,
        .required_pctl = false,
+       .version = 2,
        .offload_version = 2,
        .hash_offset = 4,
        .has_accounting = true,
        .hw_features = MTK_HW_FEATURES,
        .required_clks = MT7986_CLKS_BITMAP,
        .required_pctl = false,
+       .version = 2,
        .offload_version = 2,
        .hash_offset = 4,
        .has_accounting = true,
        .hw_features = MTK_HW_FEATURES_MT7628,
        .required_clks = MT7628_CLKS_BITMAP,
        .required_pctl = false,
+       .version = 1,
        .txrx = {
                .txd_size = sizeof(struct mtk_tx_dma),
                .rxd_size = sizeof(struct mtk_rx_dma),
 
        MTK_SHARED_INT_BIT,
        MTK_TRGMII_MT7621_CLK_BIT,
        MTK_QDMA_BIT,
-       MTK_NETSYS_V2_BIT,
        MTK_SOC_MT7628_BIT,
        MTK_RSTCTRL_PPE1_BIT,
        MTK_U3_COPHY_V2_BIT,
 #define MTK_SHARED_INT         BIT(MTK_SHARED_INT_BIT)
 #define MTK_TRGMII_MT7621_CLK  BIT(MTK_TRGMII_MT7621_CLK_BIT)
 #define MTK_QDMA               BIT(MTK_QDMA_BIT)
-#define MTK_NETSYS_V2          BIT(MTK_NETSYS_V2_BIT)
 #define MTK_SOC_MT7628         BIT(MTK_SOC_MT7628_BIT)
 #define MTK_RSTCTRL_PPE1       BIT(MTK_RSTCTRL_PPE1_BIT)
 #define MTK_U3_COPHY_V2                BIT(MTK_U3_COPHY_V2_BIT)
 #define MT7981_CAPS  (MTK_GMAC1_SGMII | MTK_GMAC2_SGMII | MTK_GMAC2_GEPHY | \
                      MTK_MUX_GMAC12_TO_GEPHY_SGMII | MTK_QDMA | \
                      MTK_MUX_U3_GMAC2_TO_QPHY | MTK_U3_COPHY_V2 | \
-                     MTK_NETSYS_V2 | MTK_RSTCTRL_PPE1)
+                     MTK_RSTCTRL_PPE1)
 
 #define MT7986_CAPS  (MTK_GMAC1_SGMII | MTK_GMAC2_SGMII | \
                      MTK_MUX_GMAC12_TO_GEPHY_SGMII | MTK_QDMA | \
-                     MTK_NETSYS_V2 | MTK_RSTCTRL_PPE1)
+                     MTK_RSTCTRL_PPE1)
 
 struct mtk_tx_dma_desc_info {
        dma_addr_t      addr;
  * @required_pctl              A bool value to show whether the SoC requires
  *                             the extra setup for those pins used by GMAC.
  * @hash_offset                        Flow table hash offset.
+ * @version                    SoC version.
  * @foe_entry_size             Foe table entry size.
  * @has_accounting             Bool indicating support for accounting of
  *                             offloaded flows.
        bool            required_pctl;
        u8              offload_version;
        u8              hash_offset;
+       u8              version;
        u16             foe_entry_size;
        netdev_features_t hw_features;
        bool            has_accounting;
 /* the struct describing the SoC. these are declared in the soc_xyz.c files */
 extern const struct of_device_id of_mtk_match[];
 
+static inline bool mtk_is_netsys_v1(struct mtk_eth *eth)
+{
+       return eth->soc->version == 1;
+}
+
+static inline bool mtk_is_netsys_v2_or_greater(struct mtk_eth *eth)
+{
+       return eth->soc->version > 1;
+}
+
 static inline struct mtk_foe_entry *
 mtk_foe_get_entry(struct mtk_ppe *ppe, u16 hash)
 {
 
 static inline u32 mtk_get_ib1_ts_mask(struct mtk_eth *eth)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return MTK_FOE_IB1_BIND_TIMESTAMP_V2;
 
        return MTK_FOE_IB1_BIND_TIMESTAMP;
 
 static inline u32 mtk_get_ib1_ppoe_mask(struct mtk_eth *eth)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return MTK_FOE_IB1_BIND_PPPOE_V2;
 
        return MTK_FOE_IB1_BIND_PPPOE;
 
 static inline u32 mtk_get_ib1_vlan_tag_mask(struct mtk_eth *eth)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return MTK_FOE_IB1_BIND_VLAN_TAG_V2;
 
        return MTK_FOE_IB1_BIND_VLAN_TAG;
 
 static inline u32 mtk_get_ib1_vlan_layer_mask(struct mtk_eth *eth)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return MTK_FOE_IB1_BIND_VLAN_LAYER_V2;
 
        return MTK_FOE_IB1_BIND_VLAN_LAYER;
 
 static inline u32 mtk_prep_ib1_vlan_layer(struct mtk_eth *eth, u32 val)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return FIELD_PREP(MTK_FOE_IB1_BIND_VLAN_LAYER_V2, val);
 
        return FIELD_PREP(MTK_FOE_IB1_BIND_VLAN_LAYER, val);
 
 static inline u32 mtk_get_ib1_vlan_layer(struct mtk_eth *eth, u32 val)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return FIELD_GET(MTK_FOE_IB1_BIND_VLAN_LAYER_V2, val);
 
        return FIELD_GET(MTK_FOE_IB1_BIND_VLAN_LAYER, val);
 
 static inline u32 mtk_get_ib1_pkt_type_mask(struct mtk_eth *eth)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return MTK_FOE_IB1_PACKET_TYPE_V2;
 
        return MTK_FOE_IB1_PACKET_TYPE;
 
 static inline u32 mtk_get_ib1_pkt_type(struct mtk_eth *eth, u32 val)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return FIELD_GET(MTK_FOE_IB1_PACKET_TYPE_V2, val);
 
        return FIELD_GET(MTK_FOE_IB1_PACKET_TYPE, val);
 
 static inline u32 mtk_get_ib2_multicast_mask(struct mtk_eth *eth)
 {
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(eth))
                return MTK_FOE_IB2_MULTICAST_V2;
 
        return MTK_FOE_IB2_MULTICAST;
 
 
        memset(entry, 0, sizeof(*entry));
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                val = FIELD_PREP(MTK_FOE_IB1_STATE, MTK_FOE_STATE_BIND) |
                      FIELD_PREP(MTK_FOE_IB1_PACKET_TYPE_V2, type) |
                      FIELD_PREP(MTK_FOE_IB1_UDP, l4proto == IPPROTO_UDP) |
        u32 *ib2 = mtk_foe_entry_ib2(eth, entry);
        u32 val = *ib2;
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                val &= ~MTK_FOE_IB2_DEST_PORT_V2;
                val |= FIELD_PREP(MTK_FOE_IB2_DEST_PORT_V2, port);
        } else {
        struct mtk_foe_mac_info *l2 = mtk_foe_entry_l2(eth, entry);
        u32 *ib2 = mtk_foe_entry_ib2(eth, entry);
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                *ib2 &= ~MTK_FOE_IB2_PORT_MG_V2;
                *ib2 |=  FIELD_PREP(MTK_FOE_IB2_RX_IDX, txq) |
                         MTK_FOE_IB2_WDMA_WINFO_V2;
 {
        u32 *ib2 = mtk_foe_entry_ib2(eth, entry);
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                *ib2 &= ~MTK_FOE_IB2_QID_V2;
                *ib2 |= FIELD_PREP(MTK_FOE_IB2_QID_V2, queue);
                *ib2 |= MTK_FOE_IB2_PSE_QOS_V2;
        struct mtk_foe_entry *hwe;
        u32 val;
 
-       if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(eth)) {
                entry->ib1 &= ~MTK_FOE_IB1_BIND_TIMESTAMP_V2;
                entry->ib1 |= FIELD_PREP(MTK_FOE_IB1_BIND_TIMESTAMP_V2,
                                         timestamp);
        hwe->ib1 = entry->ib1;
 
        if (ppe->accounting) {
-               if (MTK_HAS_CAPS(eth->soc->caps, MTK_NETSYS_V2))
+               if (mtk_is_netsys_v2_or_greater(eth))
                        val = MTK_FOE_IB2_MIB_CNT_V2;
                else
                        val = MTK_FOE_IB2_MIB_CNT;
                         MTK_PPE_SCAN_MODE_KEEPALIVE_AGE) |
              FIELD_PREP(MTK_PPE_TB_CFG_ENTRY_NUM,
                         MTK_PPE_ENTRIES_SHIFT);
-       if (MTK_HAS_CAPS(ppe->eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(ppe->eth))
                val |= MTK_PPE_TB_CFG_INFO_SEL;
        ppe_w32(ppe, MTK_PPE_TB_CFG, val);
 
              MTK_PPE_FLOW_CFG_IP4_NAPT |
              MTK_PPE_FLOW_CFG_IP4_DSLITE |
              MTK_PPE_FLOW_CFG_IP4_NAT_FRAG;
-       if (MTK_HAS_CAPS(ppe->eth->soc->caps, MTK_NETSYS_V2))
+       if (mtk_is_netsys_v2_or_greater(ppe->eth))
                val |= MTK_PPE_MD_TOAP_BYP_CRSN0 |
                       MTK_PPE_MD_TOAP_BYP_CRSN1 |
                       MTK_PPE_MD_TOAP_BYP_CRSN2 |
 
        ppe_w32(ppe, MTK_PPE_DEFAULT_CPU_PORT, 0);
 
-       if (MTK_HAS_CAPS(ppe->eth->soc->caps, MTK_NETSYS_V2)) {
+       if (mtk_is_netsys_v2_or_greater(ppe->eth)) {
                ppe_w32(ppe, MTK_PPE_DEFAULT_CPU_PORT1, 0xcb777);
                ppe_w32(ppe, MTK_PPE_SBW_CTRL, 0x7f);
        }