target/linux/ramips/patches-4.4/0513-net-mediatek-add-swconfig-driver-for-gsw_mt762x.patch

   1 From cf5a08f1f16913da8bb24a96afaa2969b29d0827 Mon Sep 17 00:00:00 2001
   2 From: John Crispin <blogic@openwrt.org>
   3 Date: Mon, 14 Dec 2015 22:25:57 +0100
   4 Subject: [PATCH 513/513] net: mediatek: add swconfig driver for gsw_mt762x
   5
   6 Signed-off-by: John Crispin <blogic@openwrt.org>
   7 ---
   8  drivers/net/ethernet/mediatek/Makefile      |   4 +-
   9  drivers/net/ethernet/mediatek/gsw_mt7620.c  |   3 +
  10  drivers/net/ethernet/mediatek/gsw_mt7620.h  |   3 +
  11  drivers/net/ethernet/mediatek/mt7530.c      | 884 ++++++++++++++++++++++++++++
  12  drivers/net/ethernet/mediatek/mt7530.h      | 186 ++++++
  13  drivers/net/ethernet/mediatek/mtk_eth_soc.c |   9 +-
  14  drivers/net/ethernet/mediatek/mtk_eth_soc.h |   1 +
  15  drivers/net/ethernet/mediatek/soc_mt7620.c  |   1 +
  16  8 files changed, 1087 insertions(+), 4 deletions(-)
  17  create mode 100644 drivers/net/ethernet/mediatek/mt7530.c
  18  create mode 100644 drivers/net/ethernet/mediatek/mt7530.h
  19
  20 --- a/drivers/net/ethernet/mediatek/Makefile
  21 +++ b/drivers/net/ethernet/mediatek/Makefile
  22 @@ -15,6 +15,6 @@ mtk-eth-soc-$(CONFIG_NET_MEDIATEK_MT7620
  23  mtk-eth-soc-$(CONFIG_NET_MEDIATEK_MT7621)      += soc_mt7621.o
  24
  25  obj-$(CONFIG_NET_MEDIATEK_ESW_RT3050)          += esw_rt3050.o
  26 -obj-$(CONFIG_NET_MEDIATEK_GSW_MT7620)          += gsw_mt7620.o
  27 -obj-$(CONFIG_NET_MEDIATEK_GSW_MT7621)          += gsw_mt7621.o
  28 +obj-$(CONFIG_NET_MEDIATEK_GSW_MT7620)          += gsw_mt7620.o mt7530.o
  29 +obj-$(CONFIG_NET_MEDIATEK_GSW_MT7621)          += gsw_mt7621.o mt7530.o
  30  obj-$(CONFIG_NET_MEDIATEK_SOC)                 += mtk-eth-soc.o
  31 --- a/drivers/net/ethernet/mediatek/gsw_mt7620.c
  32 +++ b/drivers/net/ethernet/mediatek/gsw_mt7620.c
  33 @@ -67,6 +67,9 @@ static void mt7620_hw_init(struct mt7620
  34         rt_sysc_w32(rt_sysc_r32(SYSC_REG_CFG1) | BIT(8), SYSC_REG_CFG1);
  35         mtk_switch_w32(gsw, mtk_switch_r32(gsw, GSW_REG_CKGCR) & ~(0x3 << 4), GSW_REG_CKGCR);
  36
  37 +       /* Enable MIB stats */
  38 +       mtk_switch_w32(gsw, mtk_switch_r32(gsw, GSW_REG_MIB_CNT_EN) | (1 << 1), GSW_REG_MIB_CNT_EN);
  39 +
  40         if (of_property_read_bool(np, "mediatek,mt7530")) {
  41                 u32 val;
  42
  43 --- a/drivers/net/ethernet/mediatek/gsw_mt7620.h
  44 +++ b/drivers/net/ethernet/mediatek/gsw_mt7620.h
  45 @@ -35,6 +35,8 @@
  46  #define GSW_MDIO_ADDR_SHIFT    20
  47  #define GSW_MDIO_REG_SHIFT     25
  48
  49 +#define GSW_REG_MIB_CNT_EN     0x4000
  50 +
  51  #define GSW_REG_PORT_PMCR(x)   (0x3000 + (x * 0x100))
  52  #define GSW_REG_PORT_STATUS(x) (0x3008 + (x * 0x100))
  53  #define GSW_REG_SMACCR0                0x3fE4
  54 @@ -76,6 +78,7 @@
  55  #define PHY_PRE_EN             BIT(30)
  56  #define PMY_MDC_CONF(_x)       ((_x & 0x3f) << 24)
  57
  58 +
  59  enum {
  60         /* Global attributes. */
  61         GSW_ATTR_ENABLE_VLAN,
  62 --- /dev/null
  63 +++ b/drivers/net/ethernet/mediatek/mt7530.c
  64 @@ -0,0 +1,884 @@
  65 +/*
  66 + * This program is free software; you can redistribute it and/or
  67 + * modify it under the terms of the GNU General Public License
  68 + * as published by the Free Software Foundation; either version 2
  69 + * of the License, or (at your option) any later version.
  70 + *
  71 + * This program is distributed in the hope that it will be useful,
  72 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  73 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  74 + * GNU General Public License for more details.
  75 + *
  76 + * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
  77 + * Copyright (C) 2016 Vitaly Chekryzhev <13hakta@gmail.com>
  78 + */
  79 +
  80 +#include <linux/if.h>
  81 +#include <linux/module.h>
  82 +#include <linux/init.h>
  83 +#include <linux/list.h>
  84 +#include <linux/if_ether.h>
  85 +#include <linux/skbuff.h>
  86 +#include <linux/netdevice.h>
  87 +#include <linux/netlink.h>
  88 +#include <linux/bitops.h>
  89 +#include <net/genetlink.h>
  90 +#include <linux/switch.h>
  91 +#include <linux/delay.h>
  92 +#include <linux/phy.h>
  93 +#include <linux/netdevice.h>
  94 +#include <linux/etherdevice.h>
  95 +#include <linux/lockdep.h>
  96 +#include <linux/workqueue.h>
  97 +#include <linux/of_device.h>
  98 +
  99 +#include "mt7530.h"
 100 +
 101 +#define MT7530_CPU_PORT                6
 102 +#define MT7530_NUM_PORTS       8
 103 +#define MT7530_NUM_VLANS       16
 104 +#define MT7530_MAX_VID         4095
 105 +#define MT7530_MIN_VID         0
 106 +
 107 +/* registers */
 108 +#define REG_ESW_VLAN_VTCR              0x90
 109 +#define REG_ESW_VLAN_VAWD1             0x94
 110 +#define REG_ESW_VLAN_VAWD2             0x98
 111 +#define REG_ESW_VLAN_VTIM(x)   (0x100 + 4 * ((x) / 2))
 112 +
 113 +#define REG_ESW_VLAN_VAWD1_IVL_MAC     BIT(30)
 114 +#define REG_ESW_VLAN_VAWD1_VTAG_EN     BIT(28)
 115 +#define REG_ESW_VLAN_VAWD1_VALID       BIT(0)
 116 +
 117 +/* vlan egress mode */
 118 +enum {
 119 +       ETAG_CTRL_UNTAG = 0,
 120 +       ETAG_CTRL_TAG   = 2,
 121 +       ETAG_CTRL_SWAP  = 1,
 122 +       ETAG_CTRL_STACK = 3,
 123 +};
 124 +
 125 +#define REG_ESW_PORT_PCR(x)    (0x2004 | ((x) << 8))
 126 +#define REG_ESW_PORT_PVC(x)    (0x2010 | ((x) << 8))
 127 +#define REG_ESW_PORT_PPBV1(x)  (0x2014 | ((x) << 8))
 128 +
 129 +#define REG_HWTRAP             0x7804
 130 +
 131 +#define MIB_DESC(_s , _o, _n)   \
 132 +       {                       \
 133 +               .size = (_s),   \
 134 +               .offset = (_o), \
 135 +               .name = (_n),   \
 136 +       }
 137 +
 138 +struct mt7xxx_mib_desc {
 139 +       unsigned int size;
 140 +       unsigned int offset;
 141 +       const char *name;
 142 +};
 143 +
 144 +static const struct mt7xxx_mib_desc mt7620_mibs[] = {
 145 +       MIB_DESC(1, MT7620_MIB_STATS_PPE_AC_BCNT0, "PPE_AC_BCNT0"),
 146 +       MIB_DESC(1, MT7620_MIB_STATS_PPE_AC_PCNT0, "PPE_AC_PCNT0"),
 147 +       MIB_DESC(1, MT7620_MIB_STATS_PPE_AC_BCNT63, "PPE_AC_BCNT63"),
 148 +       MIB_DESC(1, MT7620_MIB_STATS_PPE_AC_PCNT63, "PPE_AC_PCNT63"),
 149 +       MIB_DESC(1, MT7620_MIB_STATS_PPE_MTR_CNT0, "PPE_MTR_CNT0"),
 150 +       MIB_DESC(1, MT7620_MIB_STATS_PPE_MTR_CNT63, "PPE_MTR_CNT63"),
 151 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_TX_GBCNT, "GDM1_TX_GBCNT"),
 152 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_TX_GPCNT, "GDM1_TX_GPCNT"),
 153 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_TX_SKIPCNT, "GDM1_TX_SKIPCNT"),
 154 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_TX_COLCNT, "GDM1_TX_COLCNT"),
 155 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_GBCNT1, "GDM1_RX_GBCNT1"),
 156 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_GPCNT1, "GDM1_RX_GPCNT1"),
 157 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_OERCNT, "GDM1_RX_OERCNT"),
 158 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_FERCNT, "GDM1_RX_FERCNT"),
 159 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_SERCNT, "GDM1_RX_SERCNT"),
 160 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_LERCNT, "GDM1_RX_LERCNT"),
 161 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_CERCNT, "GDM1_RX_CERCNT"),
 162 +       MIB_DESC(1, MT7620_MIB_STATS_GDM1_RX_FCCNT, "GDM1_RX_FCCNT"),
 163 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_TX_GBCNT, "GDM2_TX_GBCNT"),
 164 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_TX_GPCNT, "GDM2_TX_GPCNT"),
 165 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_TX_SKIPCNT, "GDM2_TX_SKIPCNT"),
 166 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_TX_COLCNT, "GDM2_TX_COLCNT"),
 167 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_GBCNT, "GDM2_RX_GBCNT"),
 168 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_GPCNT, "GDM2_RX_GPCNT"),
 169 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_OERCNT, "GDM2_RX_OERCNT"),
 170 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_FERCNT, "GDM2_RX_FERCNT"),
 171 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_SERCNT, "GDM2_RX_SERCNT"),
 172 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_LERCNT, "GDM2_RX_LERCNT"),
 173 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_CERCNT, "GDM2_RX_CERCNT"),
 174 +       MIB_DESC(1, MT7620_MIB_STATS_GDM2_RX_FCCNT, "GDM2_RX_FCCNT")
 175 +};
 176 +
 177 +static const struct mt7xxx_mib_desc mt7620_port_mibs[] = {
 178 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_TGPCN,  "TxGPC"),
 179 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_TBOCN,  "TxBOC"),
 180 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_TGOCN,  "TxGOC"),
 181 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_TEPCN,  "TxEPC"),
 182 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_RGPCN,  "RxGPC"),
 183 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_RBOCN,  "RxBOC"),
 184 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_RGOCN,  "RxGOC"),
 185 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_REPC1N, "RxEPC1"),
 186 +       MIB_DESC(1, MT7620_MIB_STATS_PORT_REPC2N, "RxEPC2")
 187 +};
 188 +
 189 +static const struct mt7xxx_mib_desc mt7621_mibs[] = {
 190 +       MIB_DESC(1, MT7621_STATS_TDPC, "TxDrop"),
 191 +       MIB_DESC(1, MT7621_STATS_TCRC, "TxCRC"),
 192 +       MIB_DESC(1, MT7621_STATS_TUPC, "TxUni"),
 193 +       MIB_DESC(1, MT7621_STATS_TMPC, "TxMulti"),
 194 +       MIB_DESC(1, MT7621_STATS_TBPC, "TxBroad"),
 195 +       MIB_DESC(1, MT7621_STATS_TCEC, "TxCollision"),
 196 +       MIB_DESC(1, MT7621_STATS_TSCEC, "TxSingleCol"),
 197 +       MIB_DESC(1, MT7621_STATS_TMCEC, "TxMultiCol"),
 198 +       MIB_DESC(1, MT7621_STATS_TDEC, "TxDefer"),
 199 +       MIB_DESC(1, MT7621_STATS_TLCEC, "TxLateCol"),
 200 +       MIB_DESC(1, MT7621_STATS_TXCEC, "TxExcCol"),
 201 +       MIB_DESC(1, MT7621_STATS_TPPC, "TxPause"),
 202 +       MIB_DESC(1, MT7621_STATS_TL64PC, "Tx64Byte"),
 203 +       MIB_DESC(1, MT7621_STATS_TL65PC, "Tx65Byte"),
 204 +       MIB_DESC(1, MT7621_STATS_TL128PC, "Tx128Byte"),
 205 +       MIB_DESC(1, MT7621_STATS_TL256PC, "Tx256Byte"),
 206 +       MIB_DESC(1, MT7621_STATS_TL512PC, "Tx512Byte"),
 207 +       MIB_DESC(1, MT7621_STATS_TL1024PC, "Tx1024Byte"),
 208 +       MIB_DESC(2, MT7621_STATS_TOC, "TxByte"),
 209 +       MIB_DESC(1, MT7621_STATS_RDPC, "RxDrop"),
 210 +       MIB_DESC(1, MT7621_STATS_RFPC, "RxFiltered"),
 211 +       MIB_DESC(1, MT7621_STATS_RUPC, "RxUni"),
 212 +       MIB_DESC(1, MT7621_STATS_RMPC, "RxMulti"),
 213 +       MIB_DESC(1, MT7621_STATS_RBPC, "RxBroad"),
 214 +       MIB_DESC(1, MT7621_STATS_RAEPC, "RxAlignErr"),
 215 +       MIB_DESC(1, MT7621_STATS_RCEPC, "RxCRC"),
 216 +       MIB_DESC(1, MT7621_STATS_RUSPC, "RxUnderSize"),
 217 +       MIB_DESC(1, MT7621_STATS_RFEPC, "RxFragment"),
 218 +       MIB_DESC(1, MT7621_STATS_ROSPC, "RxOverSize"),
 219 +       MIB_DESC(1, MT7621_STATS_RJEPC, "RxJabber"),
 220 +       MIB_DESC(1, MT7621_STATS_RPPC, "RxPause"),
 221 +       MIB_DESC(1, MT7621_STATS_RL64PC, "Rx64Byte"),
 222 +       MIB_DESC(1, MT7621_STATS_RL65PC, "Rx65Byte"),
 223 +       MIB_DESC(1, MT7621_STATS_RL128PC, "Rx128Byte"),
 224 +       MIB_DESC(1, MT7621_STATS_RL256PC, "Rx256Byte"),
 225 +       MIB_DESC(1, MT7621_STATS_RL512PC, "Rx512Byte"),
 226 +       MIB_DESC(1, MT7621_STATS_RL1024PC, "Rx1024Byte"),
 227 +       MIB_DESC(2, MT7621_STATS_ROC, "RxByte"),
 228 +       MIB_DESC(1, MT7621_STATS_RDPC_CTRL, "RxCtrlDrop"),
 229 +       MIB_DESC(1, MT7621_STATS_RDPC_ING, "RxIngDrop"),
 230 +       MIB_DESC(1, MT7621_STATS_RDPC_ARL, "RxARLDrop")
 231 +};
 232 +
 233 +enum {
 234 +       /* Global attributes. */
 235 +       MT7530_ATTR_ENABLE_VLAN,
 236 +};
 237 +
 238 +struct mt7530_port_entry {
 239 +       u16     pvid;
 240 +};
 241 +
 242 +struct mt7530_vlan_entry {
 243 +       u16     vid;
 244 +       u8      member;
 245 +       u8      etags;
 246 +};
 247 +
 248 +struct mt7530_priv {
 249 +       void __iomem            *base;
 250 +       struct mii_bus          *bus;
 251 +       struct switch_dev       swdev;
 252 +
 253 +       bool                    global_vlan_enable;
 254 +       struct mt7530_vlan_entry        vlan_entries[MT7530_NUM_VLANS];
 255 +       struct mt7530_port_entry        port_entries[MT7530_NUM_PORTS];
 256 +};
 257 +
 258 +struct mt7530_mapping {
 259 +       char    *name;
 260 +       u16     pvids[MT7530_NUM_PORTS];
 261 +       u8      members[MT7530_NUM_VLANS];
 262 +       u8      etags[MT7530_NUM_VLANS];
 263 +       u16     vids[MT7530_NUM_VLANS];
 264 +} mt7530_defaults[] = {
 265 +       {
 266 +               .name = "llllw",
 267 +               .pvids = { 1, 1, 1, 1, 2, 1, 1 },
 268 +               .members = { 0, 0x6f, 0x50 },
 269 +               .etags = { 0, 0x40, 0x40 },
 270 +               .vids = { 0, 1, 2 },
 271 +       }, {
 272 +               .name = "wllll",
 273 +               .pvids = { 2, 1, 1, 1, 1, 1, 1 },
 274 +               .members = { 0, 0x7e, 0x41 },
 275 +               .etags = { 0, 0x40, 0x40 },
 276 +               .vids = { 0, 1, 2 },
 277 +       },
 278 +};
 279 +
 280 +struct mt7530_mapping*
 281 +mt7530_find_mapping(struct device_node *np)
 282 +{
 283 +       const char *map;
 284 +       int i;
 285 +
 286 +       if (of_property_read_string(np, "mediatek,portmap", &map))
 287 +               return NULL;
 288 +
 289 +       for (i = 0; i < ARRAY_SIZE(mt7530_defaults); i++)
 290 +               if (!strcmp(map, mt7530_defaults[i].name))
 291 +                       return &mt7530_defaults[i];
 292 +
 293 +       return NULL;
 294 +}
 295 +
 296 +static void
 297 +mt7530_apply_mapping(struct mt7530_priv *mt7530, struct mt7530_mapping *map)
 298 +{
 299 +       int i = 0;
 300 +
 301 +       for (i = 0; i < MT7530_NUM_PORTS; i++)
 302 +               mt7530->port_entries[i].pvid = map->pvids[i];
 303 +
 304 +       for (i = 0; i < MT7530_NUM_VLANS; i++) {
 305 +               mt7530->vlan_entries[i].member = map->members[i];
 306 +               mt7530->vlan_entries[i].etags = map->etags[i];
 307 +               mt7530->vlan_entries[i].vid = map->vids[i];
 308 +       }
 309 +}
 310 +
 311 +static int
 312 +mt7530_reset_switch(struct switch_dev *dev)
 313 +{
 314 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 315 +       int i;
 316 +
 317 +       memset(priv->port_entries, 0, sizeof(priv->port_entries));
 318 +       memset(priv->vlan_entries, 0, sizeof(priv->vlan_entries));
 319 +
 320 +       /* set default vid of each vlan to the same number of vlan, so the vid
 321 +        * won't need be set explicitly.
 322 +        */
 323 +       for (i = 0; i < MT7530_NUM_VLANS; i++) {
 324 +               priv->vlan_entries[i].vid = i;
 325 +       }
 326 +
 327 +       return 0;
 328 +}
 329 +
 330 +static int
 331 +mt7530_get_vlan_enable(struct switch_dev *dev,
 332 +                          const struct switch_attr *attr,
 333 +                          struct switch_val *val)
 334 +{
 335 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 336 +
 337 +       val->value.i = priv->global_vlan_enable;
 338 +
 339 +       return 0;
 340 +}
 341 +
 342 +static int
 343 +mt7530_set_vlan_enable(struct switch_dev *dev,
 344 +                          const struct switch_attr *attr,
 345 +                          struct switch_val *val)
 346 +{
 347 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 348 +
 349 +       priv->global_vlan_enable = val->value.i != 0;
 350 +
 351 +       return 0;
 352 +}
 353 +
 354 +static u32
 355 +mt7530_r32(struct mt7530_priv *priv, u32 reg)
 356 +{
 357 +       u32 val;
 358 +       if (priv->bus) {
 359 +               u16 high, low;
 360 +
 361 +               mdiobus_write(priv->bus, 0x1f, 0x1f, (reg >> 6) & 0x3ff);
 362 +               low = mdiobus_read(priv->bus, 0x1f, (reg >> 2) & 0xf);
 363 +               high = mdiobus_read(priv->bus, 0x1f, 0x10);
 364 +
 365 +               return (high << 16) | (low & 0xffff);
 366 +       }
 367 +
 368 +       val = ioread32(priv->base + reg);
 369 +       pr_debug("MT7530 MDIO Read [%04x]=%08x\n", reg, val);
 370 +
 371 +       return val;
 372 +}
 373 +
 374 +static void
 375 +mt7530_w32(struct mt7530_priv *priv, u32 reg, u32 val)
 376 +{
 377 +       if (priv->bus) {
 378 +               mdiobus_write(priv->bus, 0x1f, 0x1f, (reg >> 6) & 0x3ff);
 379 +               mdiobus_write(priv->bus, 0x1f, (reg >> 2) & 0xf,  val & 0xffff);
 380 +               mdiobus_write(priv->bus, 0x1f, 0x10, val >> 16);
 381 +               return;
 382 +       }
 383 +
 384 +       pr_debug("MT7530 MDIO Write[%04x]=%08x\n", reg, val);
 385 +       iowrite32(val, priv->base + reg);
 386 +}
 387 +
 388 +static void
 389 +mt7530_vtcr(struct mt7530_priv *priv, u32 cmd, u32 val)
 390 +{
 391 +       int i;
 392 +
 393 +       mt7530_w32(priv, REG_ESW_VLAN_VTCR, BIT(31) | (cmd << 12) | val);
 394 +
 395 +       for (i = 0; i < 20; i++) {
 396 +               u32 val = mt7530_r32(priv, REG_ESW_VLAN_VTCR);
 397 +
 398 +               if ((val & BIT(31)) == 0)
 399 +                       break;
 400 +
 401 +               udelay(1000);
 402 +       }
 403 +       if (i == 20)
 404 +               printk("mt7530: vtcr timeout\n");
 405 +}
 406 +
 407 +static int
 408 +mt7530_get_port_pvid(struct switch_dev *dev, int port, int *val)
 409 +{
 410 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 411 +
 412 +       if (port >= MT7530_NUM_PORTS)
 413 +               return -EINVAL;
 414 +
 415 +       *val = mt7530_r32(priv, REG_ESW_PORT_PPBV1(port));
 416 +       *val &= 0xfff;
 417 +
 418 +       return 0;
 419 +}
 420 +
 421 +static int
 422 +mt7530_set_port_pvid(struct switch_dev *dev, int port, int pvid)
 423 +{
 424 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 425 +
 426 +       if (port >= MT7530_NUM_PORTS)
 427 +               return -EINVAL;
 428 +
 429 +       if (pvid < MT7530_MIN_VID || pvid > MT7530_MAX_VID)
 430 +               return -EINVAL;
 431 +
 432 +       priv->port_entries[port].pvid = pvid;
 433 +
 434 +       return 0;
 435 +}
 436 +
 437 +static int
 438 +mt7530_get_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 439 +{
 440 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 441 +       u32 member;
 442 +       u32 etags;
 443 +       int i;
 444 +
 445 +       val->len = 0;
 446 +
 447 +       if (val->port_vlan < 0 || val->port_vlan >= MT7530_NUM_VLANS)
 448 +               return -EINVAL;
 449 +
 450 +       mt7530_vtcr(priv, 0, val->port_vlan);
 451 +
 452 +       member = mt7530_r32(priv, REG_ESW_VLAN_VAWD1);
 453 +       member >>= 16;
 454 +       member &= 0xff;
 455 +
 456 +       etags = mt7530_r32(priv, REG_ESW_VLAN_VAWD2);
 457 +
 458 +       for (i = 0; i < MT7530_NUM_PORTS; i++) {
 459 +               struct switch_port *p;
 460 +               int etag;
 461 +
 462 +               if (!(member & BIT(i)))
 463 +                       continue;
 464 +
 465 +               p = &val->value.ports[val->len++];
 466 +               p->id = i;
 467 +
 468 +               etag = (etags >> (i * 2)) & 0x3;
 469 +
 470 +               if (etag == ETAG_CTRL_TAG)
 471 +                       p->flags |= BIT(SWITCH_PORT_FLAG_TAGGED);
 472 +               else if (etag != ETAG_CTRL_UNTAG)
 473 +                       printk("vlan egress tag control neither untag nor tag.\n");
 474 +       }
 475 +
 476 +       return 0;
 477 +}
 478 +
 479 +static int
 480 +mt7530_set_vlan_ports(struct switch_dev *dev, struct switch_val *val)
 481 +{
 482 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 483 +       u8 member = 0;
 484 +       u8 etags = 0;
 485 +       int i;
 486 +
 487 +       if (val->port_vlan < 0 || val->port_vlan >= MT7530_NUM_VLANS ||
 488 +                       val->len > MT7530_NUM_PORTS)
 489 +               return -EINVAL;
 490 +
 491 +       for (i = 0; i < val->len; i++) {
 492 +               struct switch_port *p = &val->value.ports[i];
 493 +
 494 +               if (p->id >= MT7530_NUM_PORTS)
 495 +                       return -EINVAL;
 496 +
 497 +               member |= BIT(p->id);
 498 +
 499 +               if (p->flags & BIT(SWITCH_PORT_FLAG_TAGGED))
 500 +                       etags |= BIT(p->id);
 501 +       }
 502 +       priv->vlan_entries[val->port_vlan].member = member;
 503 +       priv->vlan_entries[val->port_vlan].etags = etags;
 504 +
 505 +       return 0;
 506 +}
 507 +
 508 +static int
 509 +mt7530_set_vid(struct switch_dev *dev, const struct switch_attr *attr,
 510 +               struct switch_val *val)
 511 +{
 512 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 513 +       int vlan;
 514 +       u16 vid;
 515 +
 516 +       vlan = val->port_vlan;
 517 +       vid = (u16)val->value.i;
 518 +
 519 +       if (vlan < 0 || vlan >= MT7530_NUM_VLANS)
 520 +               return -EINVAL;
 521 +
 522 +       if (vid < MT7530_MIN_VID || vid > MT7530_MAX_VID)
 523 +               return -EINVAL;
 524 +
 525 +       priv->vlan_entries[vlan].vid = vid;
 526 +       return 0;
 527 +}
 528 +
 529 +static int
 530 +mt7530_get_vid(struct switch_dev *dev, const struct switch_attr *attr,
 531 +               struct switch_val *val)
 532 +{
 533 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 534 +       u32 vid;
 535 +       int vlan;
 536 +
 537 +       vlan = val->port_vlan;
 538 +
 539 +       vid = mt7530_r32(priv, REG_ESW_VLAN_VTIM(vlan));
 540 +       if (vlan & 1)
 541 +               vid = vid >> 12;
 542 +       vid &= 0xfff;
 543 +
 544 +       val->value.i = vid;
 545 +       return 0;
 546 +}
 547 +
 548 +static int
 549 +mt7530_apply_config(struct switch_dev *dev)
 550 +{
 551 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 552 +       int i, j;
 553 +       u8 tag_ports;
 554 +       u8 untag_ports;
 555 +
 556 +       if (!priv->global_vlan_enable) {
 557 +               for (i = 0; i < MT7530_NUM_PORTS; i++)
 558 +                       mt7530_w32(priv, REG_ESW_PORT_PCR(i), 0x00ff0000);
 559 +
 560 +               for (i = 0; i < MT7530_NUM_PORTS; i++)
 561 +                       mt7530_w32(priv, REG_ESW_PORT_PVC(i), 0x810000c0);
 562 +
 563 +               return 0;
 564 +       }
 565 +
 566 +       /* set all ports as security mode */
 567 +       for (i = 0; i < MT7530_NUM_PORTS; i++)
 568 +               mt7530_w32(priv, REG_ESW_PORT_PCR(i), 0x00ff0003);
 569 +
 570 +       /* check if a port is used in tag/untag vlan egress mode */
 571 +       tag_ports = 0;
 572 +       untag_ports = 0;
 573 +
 574 +       for (i = 0; i < MT7530_NUM_VLANS; i++) {
 575 +               u8 member = priv->vlan_entries[i].member;
 576 +               u8 etags = priv->vlan_entries[i].etags;
 577 +
 578 +               if (!member)
 579 +                       continue;
 580 +
 581 +               for (j = 0; j < MT7530_NUM_PORTS; j++) {
 582 +                       if (!(member & BIT(j)))
 583 +                               continue;
 584 +
 585 +                       if (etags & BIT(j))
 586 +                               tag_ports |= 1u << j;
 587 +                       else
 588 +                               untag_ports |= 1u << j;
 589 +               }
 590 +       }
 591 +
 592 +       /* set all untag-only ports as transparent and the rest as user port */
 593 +       for (i = 0; i < MT7530_NUM_PORTS; i++) {
 594 +               u32 pvc_mode = 0x81000000;
 595 +
 596 +               if (untag_ports & BIT(i) && !(tag_ports & BIT(i)))
 597 +                       pvc_mode = 0x810000c0;
 598 +
 599 +               mt7530_w32(priv, REG_ESW_PORT_PVC(i), pvc_mode);
 600 +       }
 601 +
 602 +       for (i = 0; i < MT7530_NUM_VLANS; i++) {
 603 +               u16 vid = priv->vlan_entries[i].vid;
 604 +               u8 member = priv->vlan_entries[i].member;
 605 +               u8 etags = priv->vlan_entries[i].etags;
 606 +               u32 val;
 607 +
 608 +               /* vid of vlan */
 609 +               val = mt7530_r32(priv, REG_ESW_VLAN_VTIM(i));
 610 +               if (i % 2 == 0) {
 611 +                       val &= 0xfff000;
 612 +                       val |= vid;
 613 +               } else {
 614 +                       val &= 0xfff;
 615 +                       val |= (vid << 12);
 616 +               }
 617 +               mt7530_w32(priv, REG_ESW_VLAN_VTIM(i), val);
 618 +
 619 +               /* vlan port membership */
 620 +               if (member)
 621 +                       mt7530_w32(priv, REG_ESW_VLAN_VAWD1, REG_ESW_VLAN_VAWD1_IVL_MAC |
 622 +                               REG_ESW_VLAN_VAWD1_VTAG_EN | (member << 16) |
 623 +                               REG_ESW_VLAN_VAWD1_VALID);
 624 +               else
 625 +                       mt7530_w32(priv, REG_ESW_VLAN_VAWD1, 0);
 626 +
 627 +               /* egress mode */
 628 +               val = 0;
 629 +               for (j = 0; j < MT7530_NUM_PORTS; j++) {
 630 +                       if (etags & BIT(j))
 631 +                               val |= ETAG_CTRL_TAG << (j * 2);
 632 +                       else
 633 +                               val |= ETAG_CTRL_UNTAG << (j * 2);
 634 +               }
 635 +               mt7530_w32(priv, REG_ESW_VLAN_VAWD2, val);
 636 +
 637 +               /* write to vlan table */
 638 +               mt7530_vtcr(priv, 1, i);
 639 +       }
 640 +
 641 +       /* Port Default PVID */
 642 +       for (i = 0; i < MT7530_NUM_PORTS; i++) {
 643 +               u32 val;
 644 +               val = mt7530_r32(priv, REG_ESW_PORT_PPBV1(i));
 645 +               val &= ~0xfff;
 646 +               val |= priv->port_entries[i].pvid;
 647 +               mt7530_w32(priv, REG_ESW_PORT_PPBV1(i), val);
 648 +       }
 649 +
 650 +       return 0;
 651 +}
 652 +
 653 +static int
 654 +mt7530_get_port_link(struct switch_dev *dev,  int port,
 655 +                       struct switch_port_link *link)
 656 +{
 657 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 658 +       u32 speed, pmsr;
 659 +
 660 +       if (port < 0 || port >= MT7530_NUM_PORTS)
 661 +               return -EINVAL;
 662 +
 663 +       pmsr = mt7530_r32(priv, 0x3008 + (0x100 * port));
 664 +
 665 +       link->link = pmsr & 1;
 666 +       link->duplex = (pmsr >> 1) & 1;
 667 +       speed = (pmsr >> 2) & 3;
 668 +
 669 +       switch (speed) {
 670 +       case 0:
 671 +               link->speed = SWITCH_PORT_SPEED_10;
 672 +               break;
 673 +       case 1:
 674 +               link->speed = SWITCH_PORT_SPEED_100;
 675 +               break;
 676 +       case 2:
 677 +       case 3: /* forced gige speed can be 2 or 3 */
 678 +               link->speed = SWITCH_PORT_SPEED_1000;
 679 +               break;
 680 +       default:
 681 +               link->speed = SWITCH_PORT_SPEED_UNKNOWN;
 682 +               break;
 683 +       }
 684 +
 685 +       return 0;
 686 +}
 687 +
 688 +static u64 get_mib_counter(struct mt7530_priv *priv, int i, int port)
 689 +{
 690 +       unsigned int port_base;
 691 +       u64 lo;
 692 +
 693 +       port_base = MT7621_MIB_COUNTER_BASE +
 694 +                   MT7621_MIB_COUNTER_PORT_OFFSET * port;
 695 +
 696 +       lo = mt7530_r32(priv, port_base + mt7621_mibs[i].offset);
 697 +       if (mt7621_mibs[i].size == 2) {
 698 +               u64 hi;
 699 +
 700 +               hi = mt7530_r32(priv, port_base + mt7621_mibs[i].offset + 4);
 701 +               lo |= hi << 32;
 702 +       }
 703 +
 704 +       return lo;
 705 +}
 706 +
 707 +static int mt7621_sw_get_port_mib(struct switch_dev *dev,
 708 +                                 const struct switch_attr *attr,
 709 +                                 struct switch_val *val)
 710 +{
 711 +       static char buf[4096];
 712 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 713 +       int i, len = 0;
 714 +
 715 +       if (val->port_vlan >= MT7530_NUM_PORTS)
 716 +               return -EINVAL;
 717 +
 718 +       len += snprintf(buf + len, sizeof(buf) - len,
 719 +                       "Port %d MIB counters\n", val->port_vlan);
 720 +
 721 +       for (i = 0; i < ARRAY_SIZE(mt7621_mibs); ++i) {
 722 +               u64 counter;
 723 +               len += snprintf(buf + len, sizeof(buf) - len,
 724 +                               "%-11s: ", mt7621_mibs[i].name);
 725 +               counter = get_mib_counter(priv, i, val->port_vlan);
 726 +               len += snprintf(buf + len, sizeof(buf) - len, "%llu\n",
 727 +                               counter);
 728 +       }
 729 +
 730 +       val->value.s = buf;
 731 +       val->len = len;
 732 +       return 0;
 733 +}
 734 +
 735 +static u64 get_mib_counter_7620(struct mt7530_priv *priv, int i)
 736 +{
 737 +       return mt7530_r32(priv, MT7620_MIB_COUNTER_BASE + mt7620_mibs[i].offset);
 738 +}
 739 +
 740 +static u64 get_mib_counter_port_7620(struct mt7530_priv *priv, int i, int port)
 741 +{
 742 +       return mt7530_r32(priv,
 743 +                       MT7620_MIB_COUNTER_BASE_PORT +
 744 +                       (MT7620_MIB_COUNTER_PORT_OFFSET * port) +
 745 +                       mt7620_port_mibs[i].offset);
 746 +}
 747 +
 748 +static int mt7530_sw_get_mib(struct switch_dev *dev,
 749 +                                 const struct switch_attr *attr,
 750 +                                 struct switch_val *val)
 751 +{
 752 +       static char buf[4096];
 753 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 754 +       int i, len = 0;
 755 +
 756 +       len += snprintf(buf + len, sizeof(buf) - len, "Switch MIB counters\n");
 757 +
 758 +       for (i = 0; i < ARRAY_SIZE(mt7620_mibs); ++i) {
 759 +               u64 counter;
 760 +               len += snprintf(buf + len, sizeof(buf) - len,
 761 +                               "%-11s: ", mt7620_mibs[i].name);
 762 +               counter = get_mib_counter_7620(priv, i);
 763 +               len += snprintf(buf + len, sizeof(buf) - len, "%llu\n",
 764 +                               counter);
 765 +       }
 766 +
 767 +       val->value.s = buf;
 768 +       val->len = len;
 769 +       return 0;
 770 +}
 771 +
 772 +static int mt7530_sw_get_port_mib(struct switch_dev *dev,
 773 +                                 const struct switch_attr *attr,
 774 +                                 struct switch_val *val)
 775 +{
 776 +       static char buf[4096];
 777 +       struct mt7530_priv *priv = container_of(dev, struct mt7530_priv, swdev);
 778 +       int i, len = 0;
 779 +
 780 +       if (val->port_vlan >= MT7530_NUM_PORTS)
 781 +               return -EINVAL;
 782 +
 783 +       len += snprintf(buf + len, sizeof(buf) - len,
 784 +                       "Port %d MIB counters\n", val->port_vlan);
 785 +
 786 +       for (i = 0; i < ARRAY_SIZE(mt7620_port_mibs); ++i) {
 787 +               u64 counter;
 788 +               len += snprintf(buf + len, sizeof(buf) - len,
 789 +                               "%-11s: ", mt7620_port_mibs[i].name);
 790 +               counter = get_mib_counter_port_7620(priv, i, val->port_vlan);
 791 +               len += snprintf(buf + len, sizeof(buf) - len, "%llu\n",
 792 +                               counter);
 793 +       }
 794 +
 795 +       val->value.s = buf;
 796 +       val->len = len;
 797 +       return 0;
 798 +}
 799 +
 800 +static const struct switch_attr mt7530_global[] = {
 801 +       {
 802 +               .type = SWITCH_TYPE_INT,
 803 +               .name = "enable_vlan",
 804 +               .description = "VLAN mode (1:enabled)",
 805 +               .max = 1,
 806 +               .id = MT7530_ATTR_ENABLE_VLAN,
 807 +               .get = mt7530_get_vlan_enable,
 808 +               .set = mt7530_set_vlan_enable,
 809 +       }, {
 810 +               .type = SWITCH_TYPE_STRING,
 811 +               .name = "mib",
 812 +               .description = "Get MIB counters for switch",
 813 +               .get = mt7530_sw_get_mib,
 814 +               .set = NULL,
 815 +       },
 816 +};
 817 +
 818 +static const struct switch_attr mt7621_port[] = {
 819 +       {
 820 +               .type = SWITCH_TYPE_STRING,
 821 +               .name = "mib",
 822 +               .description = "Get MIB counters for port",
 823 +               .get = mt7621_sw_get_port_mib,
 824 +               .set = NULL,
 825 +       },
 826 +};
 827 +
 828 +static const struct switch_attr mt7530_port[] = {
 829 +       {
 830 +               .type = SWITCH_TYPE_STRING,
 831 +               .name = "mib",
 832 +               .description = "Get MIB counters for port",
 833 +               .get = mt7530_sw_get_port_mib,
 834 +               .set = NULL,
 835 +       },
 836 +};
 837 +
 838 +static const struct switch_attr mt7530_vlan[] = {
 839 +       {
 840 +               .type = SWITCH_TYPE_INT,
 841 +               .name = "vid",
 842 +               .description = "VLAN ID (0-4094)",
 843 +               .set = mt7530_set_vid,
 844 +               .get = mt7530_get_vid,
 845 +               .max = 4094,
 846 +       },
 847 +};
 848 +
 849 +static const struct switch_dev_ops mt7621_ops = {
 850 +       .attr_global = {
 851 +               .attr = mt7530_global,
 852 +               .n_attr = ARRAY_SIZE(mt7530_global),
 853 +       },
 854 +       .attr_port = {
 855 +               .attr = mt7621_port,
 856 +               .n_attr = ARRAY_SIZE(mt7621_port),
 857 +       },
 858 +       .attr_vlan = {
 859 +               .attr = mt7530_vlan,
 860 +               .n_attr = ARRAY_SIZE(mt7530_vlan),
 861 +       },
 862 +       .get_vlan_ports = mt7530_get_vlan_ports,
 863 +       .set_vlan_ports = mt7530_set_vlan_ports,
 864 +       .get_port_pvid = mt7530_get_port_pvid,
 865 +       .set_port_pvid = mt7530_set_port_pvid,
 866 +       .get_port_link = mt7530_get_port_link,
 867 +       .apply_config = mt7530_apply_config,
 868 +       .reset_switch = mt7530_reset_switch,
 869 +};
 870 +
 871 +static const struct switch_dev_ops mt7530_ops = {
 872 +       .attr_global = {
 873 +               .attr = mt7530_global,
 874 +               .n_attr = ARRAY_SIZE(mt7530_global),
 875 +       },
 876 +       .attr_port = {
 877 +               .attr = mt7530_port,
 878 +               .n_attr = ARRAY_SIZE(mt7530_port),
 879 +       },
 880 +       .attr_vlan = {
 881 +               .attr = mt7530_vlan,
 882 +               .n_attr = ARRAY_SIZE(mt7530_vlan),
 883 +       },
 884 +       .get_vlan_ports = mt7530_get_vlan_ports,
 885 +       .set_vlan_ports = mt7530_set_vlan_ports,
 886 +       .get_port_pvid = mt7530_get_port_pvid,
 887 +       .set_port_pvid = mt7530_set_port_pvid,
 888 +       .get_port_link = mt7530_get_port_link,
 889 +       .apply_config = mt7530_apply_config,
 890 +       .reset_switch = mt7530_reset_switch,
 891 +};
 892 +
 893 +int
 894 +mt7530_probe(struct device *dev, void __iomem *base, struct mii_bus *bus, int vlan)
 895 +{
 896 +       struct switch_dev *swdev;
 897 +       struct mt7530_priv *mt7530;
 898 +       struct mt7530_mapping *map;
 899 +       int ret;
 900 +
 901 +       mt7530 = devm_kzalloc(dev, sizeof(struct mt7530_priv), GFP_KERNEL);
 902 +       if (!mt7530)
 903 +               return -ENOMEM;
 904 +
 905 +       mt7530->base = base;
 906 +       mt7530->bus = bus;
 907 +       mt7530->global_vlan_enable = vlan;
 908 +
 909 +       swdev = &mt7530->swdev;
 910 +       if (bus) {
 911 +               swdev->alias = "mt7530";
 912 +               swdev->name = "mt7530";
 913 +       } else if (IS_ENABLED(CONFIG_SOC_MT7621)) {
 914 +               swdev->alias = "mt7621";
 915 +               swdev->name = "mt7621";
 916 +       } else {
 917 +               swdev->alias = "mt7620";
 918 +               swdev->name = "mt7620";
 919 +       }
 920 +       swdev->cpu_port = MT7530_CPU_PORT;
 921 +       swdev->ports = MT7530_NUM_PORTS;
 922 +       swdev->vlans = MT7530_NUM_VLANS;
 923 +       if (IS_ENABLED(CONFIG_SOC_MT7621))
 924 +               swdev->ops = &mt7621_ops;
 925 +       else
 926 +               swdev->ops = &mt7530_ops;
 927 +
 928 +       ret = register_switch(swdev, NULL);
 929 +       if (ret) {
 930 +               dev_err(dev, "failed to register mt7530\n");
 931 +               return ret;
 932 +       }
 933 +
 934 +
 935 +       map = mt7530_find_mapping(dev->of_node);
 936 +       if (map)
 937 +               mt7530_apply_mapping(mt7530, map);
 938 +       mt7530_apply_config(swdev);
 939 +
 940 +       /* magic vodoo */
 941 +       if (!IS_ENABLED(CONFIG_SOC_MT7621) && bus && mt7530_r32(mt7530, REG_HWTRAP) !=  0x1117edf) {
 942 +               dev_info(dev, "fixing up MHWTRAP register - bootloader probably played with it\n");
 943 +               mt7530_w32(mt7530, REG_HWTRAP, 0x1117edf);
 944 +       }
 945 +       dev_info(dev, "loaded %s driver\n", swdev->name);
 946 +
 947 +       return 0;
 948 +}
 949 --- /dev/null
 950 +++ b/drivers/net/ethernet/mediatek/mt7530.h
 951 @@ -0,0 +1,186 @@
 952 +/*
 953 + * This program is free software; you can redistribute it and/or
 954 + * modify it under the terms of the GNU General Public License
 955 + * as published by the Free Software Foundation; either version 2
 956 + * of the License, or (at your option) any later version.
 957 + *
 958 + * This program is distributed in the hope that it will be useful,
 959 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 960 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 961 + * GNU General Public License for more details.
 962 + *
 963 + * Copyright (C) 2013 John Crispin <blogic@openwrt.org>
 964 + * Copyright (C) 2016 Vitaly Chekryzhev <13hakta@gmail.com>
 965 + */
 966 +
 967 +#ifndef _MT7530_H__
 968 +#define _MT7530_H__
 969 +
 970 +#define MT7620_MIB_COUNTER_BASE_PORT   0x4000
 971 +#define MT7620_MIB_COUNTER_PORT_OFFSET 0x100
 972 +#define MT7620_MIB_COUNTER_BASE        0x1010
 973 +
 974 +/* PPE Accounting Group #0 Byte Counter */
 975 +#define MT7620_MIB_STATS_PPE_AC_BCNT0  0x000
 976 +
 977 +/* PPE Accounting Group #0 Packet Counter */
 978 +#define MT7620_MIB_STATS_PPE_AC_PCNT0  0x004
 979 +
 980 +/* PPE Accounting Group #63 Byte Counter */
 981 +#define MT7620_MIB_STATS_PPE_AC_BCNT63 0x1F8
 982 +
 983 +/* PPE Accounting Group #63 Packet Counter */
 984 +#define MT7620_MIB_STATS_PPE_AC_PCNT63 0x1FC
 985 +
 986 +/* PPE Meter Group #0 */
 987 +#define MT7620_MIB_STATS_PPE_MTR_CNT0  0x200
 988 +
 989 +/* PPE Meter Group #63 */
 990 +#define MT7620_MIB_STATS_PPE_MTR_CNT63 0x2FC
 991 +
 992 +/* Transmit good byte count for CPU GDM */
 993 +#define MT7620_MIB_STATS_GDM1_TX_GBCNT 0x300
 994 +
 995 +/* Transmit good packet count for CPU GDM (exclude flow control frames) */
 996 +#define MT7620_MIB_STATS_GDM1_TX_GPCNT 0x304
 997 +
 998 +/* Transmit abort count for CPU GDM */
 999 +#define MT7620_MIB_STATS_GDM1_TX_SKIPCNT       0x308
1000 +
1001 +/* Transmit collision count for CPU GDM */
1002 +#define MT7620_MIB_STATS_GDM1_TX_COLCNT        0x30C
1003 +
1004 +/* Received good byte count for CPU GDM */
1005 +#define MT7620_MIB_STATS_GDM1_RX_GBCNT1        0x320
1006 +
1007 +/* Received good packet count for CPU GDM (exclude flow control frame) */
1008 +#define MT7620_MIB_STATS_GDM1_RX_GPCNT1        0x324
1009 +
1010 +/* Received overflow error packet count for CPU GDM */
1011 +#define MT7620_MIB_STATS_GDM1_RX_OERCNT        0x328
1012 +
1013 +/* Received FCS error packet count for CPU GDM */
1014 +#define MT7620_MIB_STATS_GDM1_RX_FERCNT        0x32C
1015 +
1016 +/* Received too short error packet count for CPU GDM */
1017 +#define MT7620_MIB_STATS_GDM1_RX_SERCNT        0x330
1018 +
1019 +/* Received too long error packet count for CPU GDM */
1020 +#define MT7620_MIB_STATS_GDM1_RX_LERCNT        0x334
1021 +
1022 +/* Received IP/TCP/UDP checksum error packet count for CPU GDM */
1023 +#define MT7620_MIB_STATS_GDM1_RX_CERCNT        0x338
1024 +
1025 +/* Received flow control pkt count for CPU GDM */
1026 +#define MT7620_MIB_STATS_GDM1_RX_FCCNT 0x33C
1027 +
1028 +/* Transmit good byte count for PPE GDM */
1029 +#define MT7620_MIB_STATS_GDM2_TX_GBCNT 0x340
1030 +
1031 +/* Transmit good packet count for PPE GDM (exclude flow control frames) */
1032 +#define MT7620_MIB_STATS_GDM2_TX_GPCNT 0x344
1033 +
1034 +/* Transmit abort count for PPE GDM */
1035 +#define MT7620_MIB_STATS_GDM2_TX_SKIPCNT       0x348
1036 +
1037 +/* Transmit collision count for PPE GDM */
1038 +#define MT7620_MIB_STATS_GDM2_TX_COLCNT        0x34C
1039 +
1040 +/* Received good byte count for PPE GDM */
1041 +#define MT7620_MIB_STATS_GDM2_RX_GBCNT 0x360
1042 +
1043 +/* Received good packet count for PPE GDM (exclude flow control frame) */
1044 +#define MT7620_MIB_STATS_GDM2_RX_GPCNT 0x364
1045 +
1046 +/* Received overflow error packet count for PPE GDM */
1047 +#define MT7620_MIB_STATS_GDM2_RX_OERCNT        0x368
1048 +
1049 +/* Received FCS error packet count for PPE GDM */
1050 +#define MT7620_MIB_STATS_GDM2_RX_FERCNT        0x36C
1051 +
1052 +/* Received too short error packet count for PPE GDM */
1053 +#define MT7620_MIB_STATS_GDM2_RX_SERCNT        0x370
1054 +
1055 +/* Received too long error packet count for PPE GDM */
1056 +#define MT7620_MIB_STATS_GDM2_RX_LERCNT        0x374
1057 +
1058 +/* Received IP/TCP/UDP checksum error packet count for PPE GDM */
1059 +#define MT7620_MIB_STATS_GDM2_RX_CERCNT        0x378
1060 +
1061 +/* Received flow control pkt count for PPE GDM */
1062 +#define MT7620_MIB_STATS_GDM2_RX_FCCNT 0x37C
1063 +
1064 +/* Tx Packet Counter of Port n */
1065 +#define MT7620_MIB_STATS_PORT_TGPCN    0x10
1066 +
1067 +/* Tx Bad Octet Counter of Port n */
1068 +#define MT7620_MIB_STATS_PORT_TBOCN    0x14
1069 +
1070 +/* Tx Good Octet Counter of Port n */
1071 +#define MT7620_MIB_STATS_PORT_TGOCN    0x18
1072 +
1073 +/* Tx Event Packet Counter of Port n */
1074 +#define MT7620_MIB_STATS_PORT_TEPCN    0x1C
1075 +
1076 +/* Rx Packet Counter of Port n */
1077 +#define MT7620_MIB_STATS_PORT_RGPCN    0x20
1078 +
1079 +/* Rx Bad Octet Counter of Port n */
1080 +#define MT7620_MIB_STATS_PORT_RBOCN    0x24
1081 +
1082 +/* Rx Good Octet Counter of Port n */
1083 +#define MT7620_MIB_STATS_PORT_RGOCN    0x28
1084 +
1085 +/* Rx Event Packet Counter of Port n */
1086 +#define MT7620_MIB_STATS_PORT_REPC1N   0x2C
1087 +
1088 +/* Rx Event Packet Counter of Port n */
1089 +#define MT7620_MIB_STATS_PORT_REPC2N   0x30
1090 +
1091 +#define MT7621_MIB_COUNTER_BASE        0x4000
1092 +#define MT7621_MIB_COUNTER_PORT_OFFSET 0x100
1093 +#define MT7621_STATS_TDPC      0x00
1094 +#define MT7621_STATS_TCRC      0x04
1095 +#define MT7621_STATS_TUPC      0x08
1096 +#define MT7621_STATS_TMPC      0x0C
1097 +#define MT7621_STATS_TBPC      0x10
1098 +#define MT7621_STATS_TCEC      0x14
1099 +#define MT7621_STATS_TSCEC     0x18
1100 +#define MT7621_STATS_TMCEC     0x1C
1101 +#define MT7621_STATS_TDEC      0x20
1102 +#define MT7621_STATS_TLCEC     0x24
1103 +#define MT7621_STATS_TXCEC     0x28
1104 +#define MT7621_STATS_TPPC      0x2C
1105 +#define MT7621_STATS_TL64PC    0x30
1106 +#define MT7621_STATS_TL65PC    0x34
1107 +#define MT7621_STATS_TL128PC   0x38
1108 +#define MT7621_STATS_TL256PC   0x3C
1109 +#define MT7621_STATS_TL512PC   0x40
1110 +#define MT7621_STATS_TL1024PC  0x44
1111 +#define MT7621_STATS_TOC       0x48
1112 +#define MT7621_STATS_RDPC      0x60
1113 +#define MT7621_STATS_RFPC      0x64
1114 +#define MT7621_STATS_RUPC      0x68
1115 +#define MT7621_STATS_RMPC      0x6C
1116 +#define MT7621_STATS_RBPC      0x70
1117 +#define MT7621_STATS_RAEPC     0x74
1118 +#define MT7621_STATS_RCEPC     0x78
1119 +#define MT7621_STATS_RUSPC     0x7C
1120 +#define MT7621_STATS_RFEPC     0x80
1121 +#define MT7621_STATS_ROSPC     0x84
1122 +#define MT7621_STATS_RJEPC     0x88
1123 +#define MT7621_STATS_RPPC      0x8C
1124 +#define MT7621_STATS_RL64PC    0x90
1125 +#define MT7621_STATS_RL65PC    0x94
1126 +#define MT7621_STATS_RL128PC   0x98
1127 +#define MT7621_STATS_RL256PC   0x9C
1128 +#define MT7621_STATS_RL512PC   0xA0
1129 +#define MT7621_STATS_RL1024PC  0xA4
1130 +#define MT7621_STATS_ROC       0xA8
1131 +#define MT7621_STATS_RDPC_CTRL 0xB0
1132 +#define MT7621_STATS_RDPC_ING  0xB4
1133 +#define MT7621_STATS_RDPC_ARL  0xB8
1134 +
1135 +int mt7530_probe(struct device *dev, void __iomem *base, struct mii_bus *bus, int vlan);
1136 +
1137 +#endif
1138 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
1139 +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
1140 @@ -1291,8 +1291,13 @@ static int __init fe_init(struct net_dev
1141         }
1142
1143         err = fe_hw_init(dev);
1144 -       if (!err)
1145 -               return 0;
1146 +       if (err)
1147 +               goto err_phy_disconnect;
1148 +
1149 +       if ((priv->flags & FE_FLAG_HAS_SWITCH) && priv->soc->switch_config)
1150 +               priv->soc->switch_config(priv);
1151 +
1152 +       return 0;
1153
1154  err_phy_disconnect:
1155         if (priv->phy)
1156 --- a/drivers/net/ethernet/mediatek/mtk_eth_soc.h
1157 +++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.h
1158 @@ -383,6 +383,7 @@ struct fe_soc_data {
1159         int (*fwd_config)(struct fe_priv *priv);
1160         void (*tx_dma)(struct fe_tx_dma *txd);
1161         int (*switch_init)(struct fe_priv *priv);
1162 +       int (*switch_config)(struct fe_priv *priv);
1163         void (*port_init)(struct fe_priv *priv, struct device_node *port);
1164         int (*has_carrier)(struct fe_priv *priv);
1165         int (*mdio_init)(struct fe_priv *priv);
1166 --- a/drivers/net/ethernet/mediatek/soc_mt7620.c
1167 +++ b/drivers/net/ethernet/mediatek/soc_mt7620.c
1168 @@ -313,6 +313,7 @@ static struct fe_soc_data mt7620_data =
1169         .fwd_config = mt7620_fwd_config,
1170         .tx_dma = mt7620_tx_dma,
1171         .switch_init = mtk_gsw_init,
1172 +       .switch_config = mt7620_gsw_config,
1173         .port_init = mt7620_port_init,
1174         .reg_table = mt7620_reg_table,
1175         .pdma_glo_cfg = FE_PDMA_SIZE_16DWORDS,