drivers/net/dsa/lantiq_gswip.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Lantiq / Intel GSWIP switch driver for VRX200, xRX300 and xRX330 SoCs
   4  *
   5  * Copyright (C) 2010 Lantiq Deutschland
   6  * Copyright (C) 2012 John Crispin <john@phrozen.org>
   7  * Copyright (C) 2017 - 2019 Hauke Mehrtens <hauke@hauke-m.de>
   8  *
   9  * The VLAN and bridge model the GSWIP hardware uses does not directly
  10  * matches the model DSA uses.
  11  *
  12  * The hardware has 64 possible table entries for bridges with one VLAN
  13  * ID, one flow id and a list of ports for each bridge. All entries which
  14  * match the same flow ID are combined in the mac learning table, they
  15  * act as one global bridge.
  16  * The hardware does not support VLAN filter on the port, but on the
  17  * bridge, this driver converts the DSA model to the hardware.
  18  *
  19  * The CPU gets all the exception frames which do not match any forwarding
  20  * rule and the CPU port is also added to all bridges. This makes it possible
  21  * to handle all the special cases easily in software.
  22  * At the initialization the driver allocates one bridge table entry for
  23  * each switch port which is used when the port is used without an
  24  * explicit bridge. This prevents the frames from being forwarded
  25  * between all LAN ports by default.
  26  */
  27
  28 #include <linux/clk.h>
  29 #include <linux/delay.h>
  30 #include <linux/etherdevice.h>
  31 #include <linux/firmware.h>
  32 #include <linux/if_bridge.h>
  33 #include <linux/if_vlan.h>
  34 #include <linux/iopoll.h>
  35 #include <linux/mfd/syscon.h>
  36 #include <linux/module.h>
  37 #include <linux/of_mdio.h>
  38 #include <linux/of_net.h>
  39 #include <linux/of_platform.h>
  40 #include <linux/phy.h>
  41 #include <linux/phylink.h>
  42 #include <linux/platform_device.h>
  43 #include <linux/regmap.h>
  44 #include <linux/reset.h>
  45 #include <net/dsa.h>
  46 #include <dt-bindings/mips/lantiq_rcu_gphy.h>
  47
  48 #include "lantiq_pce.h"
  49
  50 /* GSWIP MDIO Registers */
  51 #define GSWIP_MDIO_GLOB                 0x00
  52 #define  GSWIP_MDIO_GLOB_ENABLE         BIT(15)
  53 #define GSWIP_MDIO_CTRL                 0x08
  54 #define  GSWIP_MDIO_CTRL_BUSY           BIT(12)
  55 #define  GSWIP_MDIO_CTRL_RD             BIT(11)
  56 #define  GSWIP_MDIO_CTRL_WR             BIT(10)
  57 #define  GSWIP_MDIO_CTRL_PHYAD_MASK     0x1f
  58 #define  GSWIP_MDIO_CTRL_PHYAD_SHIFT    5
  59 #define  GSWIP_MDIO_CTRL_REGAD_MASK     0x1f
  60 #define GSWIP_MDIO_READ                 0x09
  61 #define GSWIP_MDIO_WRITE                0x0A
  62 #define GSWIP_MDIO_MDC_CFG0             0x0B
  63 #define GSWIP_MDIO_MDC_CFG1             0x0C
  64 #define GSWIP_MDIO_PHYp(p)              (0x15 - (p))
  65 #define  GSWIP_MDIO_PHY_LINK_MASK       0x6000
  66 #define  GSWIP_MDIO_PHY_LINK_AUTO       0x0000
  67 #define  GSWIP_MDIO_PHY_LINK_DOWN       0x4000
  68 #define  GSWIP_MDIO_PHY_LINK_UP         0x2000
  69 #define  GSWIP_MDIO_PHY_SPEED_MASK      0x1800
  70 #define  GSWIP_MDIO_PHY_SPEED_AUTO      0x1800
  71 #define  GSWIP_MDIO_PHY_SPEED_M10       0x0000
  72 #define  GSWIP_MDIO_PHY_SPEED_M100      0x0800
  73 #define  GSWIP_MDIO_PHY_SPEED_G1        0x1000
  74 #define  GSWIP_MDIO_PHY_FDUP_MASK       0x0600
  75 #define  GSWIP_MDIO_PHY_FDUP_AUTO       0x0000
  76 #define  GSWIP_MDIO_PHY_FDUP_EN         0x0200
  77 #define  GSWIP_MDIO_PHY_FDUP_DIS        0x0600
  78 #define  GSWIP_MDIO_PHY_FCONTX_MASK     0x0180
  79 #define  GSWIP_MDIO_PHY_FCONTX_AUTO     0x0000
  80 #define  GSWIP_MDIO_PHY_FCONTX_EN       0x0100
  81 #define  GSWIP_MDIO_PHY_FCONTX_DIS      0x0180
  82 #define  GSWIP_MDIO_PHY_FCONRX_MASK     0x0060
  83 #define  GSWIP_MDIO_PHY_FCONRX_AUTO     0x0000
  84 #define  GSWIP_MDIO_PHY_FCONRX_EN       0x0020
  85 #define  GSWIP_MDIO_PHY_FCONRX_DIS      0x0060
  86 #define  GSWIP_MDIO_PHY_ADDR_MASK       0x001f
  87 #define  GSWIP_MDIO_PHY_MASK            (GSWIP_MDIO_PHY_ADDR_MASK | \
  88                                          GSWIP_MDIO_PHY_FCONRX_MASK | \
  89                                          GSWIP_MDIO_PHY_FCONTX_MASK | \
  90                                          GSWIP_MDIO_PHY_LINK_MASK | \
  91                                          GSWIP_MDIO_PHY_SPEED_MASK | \
  92                                          GSWIP_MDIO_PHY_FDUP_MASK)
  93
  94 /* GSWIP MII Registers */
  95 #define GSWIP_MII_CFGp(p)               (0x2 * (p))
  96 #define  GSWIP_MII_CFG_RESET            BIT(15)
  97 #define  GSWIP_MII_CFG_EN               BIT(14)
  98 #define  GSWIP_MII_CFG_ISOLATE          BIT(13)
  99 #define  GSWIP_MII_CFG_LDCLKDIS         BIT(12)
 100 #define  GSWIP_MII_CFG_RGMII_IBS        BIT(8)
 101 #define  GSWIP_MII_CFG_RMII_CLK         BIT(7)
 102 #define  GSWIP_MII_CFG_MODE_MIIP        0x0
 103 #define  GSWIP_MII_CFG_MODE_MIIM        0x1
 104 #define  GSWIP_MII_CFG_MODE_RMIIP       0x2
 105 #define  GSWIP_MII_CFG_MODE_RMIIM       0x3
 106 #define  GSWIP_MII_CFG_MODE_RGMII       0x4
 107 #define  GSWIP_MII_CFG_MODE_GMII        0x9
 108 #define  GSWIP_MII_CFG_MODE_MASK        0xf
 109 #define  GSWIP_MII_CFG_RATE_M2P5        0x00
 110 #define  GSWIP_MII_CFG_RATE_M25 0x10
 111 #define  GSWIP_MII_CFG_RATE_M125        0x20
 112 #define  GSWIP_MII_CFG_RATE_M50 0x30
 113 #define  GSWIP_MII_CFG_RATE_AUTO        0x40
 114 #define  GSWIP_MII_CFG_RATE_MASK        0x70
 115 #define GSWIP_MII_PCDU0                 0x01
 116 #define GSWIP_MII_PCDU1                 0x03
 117 #define GSWIP_MII_PCDU5                 0x05
 118 #define  GSWIP_MII_PCDU_TXDLY_MASK      GENMASK(2, 0)
 119 #define  GSWIP_MII_PCDU_RXDLY_MASK      GENMASK(9, 7)
 120
 121 /* GSWIP Core Registers */
 122 #define GSWIP_SWRES                     0x000
 123 #define  GSWIP_SWRES_R1                 BIT(1)  /* GSWIP Software reset */
 124 #define  GSWIP_SWRES_R0                 BIT(0)  /* GSWIP Hardware reset */
 125 #define GSWIP_VERSION                   0x013
 126 #define  GSWIP_VERSION_REV_SHIFT        0
 127 #define  GSWIP_VERSION_REV_MASK         GENMASK(7, 0)
 128 #define  GSWIP_VERSION_MOD_SHIFT        8
 129 #define  GSWIP_VERSION_MOD_MASK         GENMASK(15, 8)
 130 #define   GSWIP_VERSION_2_0             0x100
 131 #define   GSWIP_VERSION_2_1             0x021
 132 #define   GSWIP_VERSION_2_2             0x122
 133 #define   GSWIP_VERSION_2_2_ETC         0x022
 134
 135 #define GSWIP_BM_RAM_VAL(x)             (0x043 - (x))
 136 #define GSWIP_BM_RAM_ADDR               0x044
 137 #define GSWIP_BM_RAM_CTRL               0x045
 138 #define  GSWIP_BM_RAM_CTRL_BAS          BIT(15)
 139 #define  GSWIP_BM_RAM_CTRL_OPMOD        BIT(5)
 140 #define  GSWIP_BM_RAM_CTRL_ADDR_MASK    GENMASK(4, 0)
 141 #define GSWIP_BM_QUEUE_GCTRL            0x04A
 142 #define  GSWIP_BM_QUEUE_GCTRL_GL_MOD    BIT(10)
 143 /* buffer management Port Configuration Register */
 144 #define GSWIP_BM_PCFGp(p)               (0x080 + ((p) * 2))
 145 #define  GSWIP_BM_PCFG_CNTEN            BIT(0)  /* RMON Counter Enable */
 146 #define  GSWIP_BM_PCFG_IGCNT            BIT(1)  /* Ingres Special Tag RMON count */
 147 /* buffer management Port Control Register */
 148 #define GSWIP_BM_RMON_CTRLp(p)          (0x81 + ((p) * 2))
 149 #define  GSWIP_BM_CTRL_RMON_RAM1_RES    BIT(0)  /* Software Reset for RMON RAM 1 */
 150 #define  GSWIP_BM_CTRL_RMON_RAM2_RES    BIT(1)  /* Software Reset for RMON RAM 2 */
 151
 152 /* PCE */
 153 #define GSWIP_PCE_TBL_KEY(x)            (0x447 - (x))
 154 #define GSWIP_PCE_TBL_MASK              0x448
 155 #define GSWIP_PCE_TBL_VAL(x)            (0x44D - (x))
 156 #define GSWIP_PCE_TBL_ADDR              0x44E
 157 #define GSWIP_PCE_TBL_CTRL              0x44F
 158 #define  GSWIP_PCE_TBL_CTRL_BAS         BIT(15)
 159 #define  GSWIP_PCE_TBL_CTRL_TYPE        BIT(13)
 160 #define  GSWIP_PCE_TBL_CTRL_VLD         BIT(12)
 161 #define  GSWIP_PCE_TBL_CTRL_KEYFORM     BIT(11)
 162 #define  GSWIP_PCE_TBL_CTRL_GMAP_MASK   GENMASK(10, 7)
 163 #define  GSWIP_PCE_TBL_CTRL_OPMOD_MASK  GENMASK(6, 5)
 164 #define  GSWIP_PCE_TBL_CTRL_OPMOD_ADRD  0x00
 165 #define  GSWIP_PCE_TBL_CTRL_OPMOD_ADWR  0x20
 166 #define  GSWIP_PCE_TBL_CTRL_OPMOD_KSRD  0x40
 167 #define  GSWIP_PCE_TBL_CTRL_OPMOD_KSWR  0x60
 168 #define  GSWIP_PCE_TBL_CTRL_ADDR_MASK   GENMASK(4, 0)
 169 #define GSWIP_PCE_PMAP1                 0x453   /* Monitoring port map */
 170 #define GSWIP_PCE_PMAP2                 0x454   /* Default Multicast port map */
 171 #define GSWIP_PCE_PMAP3                 0x455   /* Default Unknown Unicast port map */
 172 #define GSWIP_PCE_GCTRL_0               0x456
 173 #define  GSWIP_PCE_GCTRL_0_MTFL         BIT(0)  /* MAC Table Flushing */
 174 #define  GSWIP_PCE_GCTRL_0_MC_VALID     BIT(3)
 175 #define  GSWIP_PCE_GCTRL_0_VLAN         BIT(14) /* VLAN aware Switching */
 176 #define GSWIP_PCE_GCTRL_1               0x457
 177 #define  GSWIP_PCE_GCTRL_1_MAC_GLOCK    BIT(2)  /* MAC Address table lock */
 178 #define  GSWIP_PCE_GCTRL_1_MAC_GLOCK_MOD        BIT(3) /* Mac address table lock forwarding mode */
 179 #define GSWIP_PCE_PCTRL_0p(p)           (0x480 + ((p) * 0xA))
 180 #define  GSWIP_PCE_PCTRL_0_TVM          BIT(5)  /* Transparent VLAN mode */
 181 #define  GSWIP_PCE_PCTRL_0_VREP         BIT(6)  /* VLAN Replace Mode */
 182 #define  GSWIP_PCE_PCTRL_0_INGRESS      BIT(11) /* Accept special tag in ingress */
 183 #define  GSWIP_PCE_PCTRL_0_PSTATE_LISTEN        0x0
 184 #define  GSWIP_PCE_PCTRL_0_PSTATE_RX            0x1
 185 #define  GSWIP_PCE_PCTRL_0_PSTATE_TX            0x2
 186 #define  GSWIP_PCE_PCTRL_0_PSTATE_LEARNING      0x3
 187 #define  GSWIP_PCE_PCTRL_0_PSTATE_FORWARDING    0x7
 188 #define  GSWIP_PCE_PCTRL_0_PSTATE_MASK  GENMASK(2, 0)
 189 #define GSWIP_PCE_VCTRL(p)              (0x485 + ((p) * 0xA))
 190 #define  GSWIP_PCE_VCTRL_UVR            BIT(0)  /* Unknown VLAN Rule */
 191 #define  GSWIP_PCE_VCTRL_VIMR           BIT(3)  /* VLAN Ingress Member violation rule */
 192 #define  GSWIP_PCE_VCTRL_VEMR           BIT(4)  /* VLAN Egress Member violation rule */
 193 #define  GSWIP_PCE_VCTRL_VSR            BIT(5)  /* VLAN Security */
 194 #define  GSWIP_PCE_VCTRL_VID0           BIT(6)  /* Priority Tagged Rule */
 195 #define GSWIP_PCE_DEFPVID(p)            (0x486 + ((p) * 0xA))
 196
 197 #define GSWIP_MAC_FLEN                  0x8C5
 198 #define GSWIP_MAC_CTRL_0p(p)            (0x903 + ((p) * 0xC))
 199 #define  GSWIP_MAC_CTRL_0_PADEN         BIT(8)
 200 #define  GSWIP_MAC_CTRL_0_FCS_EN        BIT(7)
 201 #define  GSWIP_MAC_CTRL_0_FCON_MASK     0x0070
 202 #define  GSWIP_MAC_CTRL_0_FCON_AUTO     0x0000
 203 #define  GSWIP_MAC_CTRL_0_FCON_RX       0x0010
 204 #define  GSWIP_MAC_CTRL_0_FCON_TX       0x0020
 205 #define  GSWIP_MAC_CTRL_0_FCON_RXTX     0x0030
 206 #define  GSWIP_MAC_CTRL_0_FCON_NONE     0x0040
 207 #define  GSWIP_MAC_CTRL_0_FDUP_MASK     0x000C
 208 #define  GSWIP_MAC_CTRL_0_FDUP_AUTO     0x0000
 209 #define  GSWIP_MAC_CTRL_0_FDUP_EN       0x0004
 210 #define  GSWIP_MAC_CTRL_0_FDUP_DIS      0x000C
 211 #define  GSWIP_MAC_CTRL_0_GMII_MASK     0x0003
 212 #define  GSWIP_MAC_CTRL_0_GMII_AUTO     0x0000
 213 #define  GSWIP_MAC_CTRL_0_GMII_MII      0x0001
 214 #define  GSWIP_MAC_CTRL_0_GMII_RGMII    0x0002
 215 #define GSWIP_MAC_CTRL_2p(p)            (0x905 + ((p) * 0xC))
 216 #define GSWIP_MAC_CTRL_2_MLEN           BIT(3) /* Maximum Untagged Frame Lnegth */
 217
 218 /* Ethernet Switch Fetch DMA Port Control Register */
 219 #define GSWIP_FDMA_PCTRLp(p)            (0xA80 + ((p) * 0x6))
 220 #define  GSWIP_FDMA_PCTRL_EN            BIT(0)  /* FDMA Port Enable */
 221 #define  GSWIP_FDMA_PCTRL_STEN          BIT(1)  /* Special Tag Insertion Enable */
 222 #define  GSWIP_FDMA_PCTRL_VLANMOD_MASK  GENMASK(4, 3)   /* VLAN Modification Control */
 223 #define  GSWIP_FDMA_PCTRL_VLANMOD_SHIFT 3       /* VLAN Modification Control */
 224 #define  GSWIP_FDMA_PCTRL_VLANMOD_DIS   (0x0 << GSWIP_FDMA_PCTRL_VLANMOD_SHIFT)
 225 #define  GSWIP_FDMA_PCTRL_VLANMOD_PRIO  (0x1 << GSWIP_FDMA_PCTRL_VLANMOD_SHIFT)
 226 #define  GSWIP_FDMA_PCTRL_VLANMOD_ID    (0x2 << GSWIP_FDMA_PCTRL_VLANMOD_SHIFT)
 227 #define  GSWIP_FDMA_PCTRL_VLANMOD_BOTH  (0x3 << GSWIP_FDMA_PCTRL_VLANMOD_SHIFT)
 228
 229 /* Ethernet Switch Store DMA Port Control Register */
 230 #define GSWIP_SDMA_PCTRLp(p)            (0xBC0 + ((p) * 0x6))
 231 #define  GSWIP_SDMA_PCTRL_EN            BIT(0)  /* SDMA Port Enable */
 232 #define  GSWIP_SDMA_PCTRL_FCEN          BIT(1)  /* Flow Control Enable */
 233 #define  GSWIP_SDMA_PCTRL_PAUFWD        BIT(3)  /* Pause Frame Forwarding */
 234
 235 #define GSWIP_TABLE_ACTIVE_VLAN         0x01
 236 #define GSWIP_TABLE_VLAN_MAPPING        0x02
 237 #define GSWIP_TABLE_MAC_BRIDGE          0x0b
 238 #define  GSWIP_TABLE_MAC_BRIDGE_STATIC  0x01    /* Static not, aging entry */
 239
 240 #define XRX200_GPHY_FW_ALIGN    (16 * 1024)
 241
 242 struct gswip_hw_info {
 243         int max_ports;
 244         int cpu_port;
 245         const struct dsa_switch_ops *ops;
 246 };
 247
 248 struct xway_gphy_match_data {
 249         char *fe_firmware_name;
 250         char *ge_firmware_name;
 251 };
 252
 253 struct gswip_gphy_fw {
 254         struct clk *clk_gate;
 255         struct reset_control *reset;
 256         u32 fw_addr_offset;
 257         char *fw_name;
 258 };
 259
 260 struct gswip_vlan {
 261         struct net_device *bridge;
 262         u16 vid;
 263         u8 fid;
 264 };
 265
 266 struct gswip_priv {
 267         __iomem void *gswip;
 268         __iomem void *mdio;
 269         __iomem void *mii;
 270         const struct gswip_hw_info *hw_info;
 271         const struct xway_gphy_match_data *gphy_fw_name_cfg;
 272         struct dsa_switch *ds;
 273         struct device *dev;
 274         struct regmap *rcu_regmap;
 275         struct gswip_vlan vlans[64];
 276         int num_gphy_fw;
 277         struct gswip_gphy_fw *gphy_fw;
 278         u32 port_vlan_filter;
 279         struct mutex pce_table_lock;
 280 };
 281
 282 struct gswip_pce_table_entry {
 283         u16 index;      // PCE_TBL_ADDR.ADDR = pData->table_index
 284         u16 table;      // PCE_TBL_CTRL.ADDR = pData->table
 285         u16 key[8];
 286         u16 val[5];
 287         u16 mask;
 288         u8 gmap;
 289         bool type;
 290         bool valid;
 291         bool key_mode;
 292 };
 293
 294 struct gswip_rmon_cnt_desc {
 295         unsigned int size;
 296         unsigned int offset;
 297         const char *name;
 298 };
 299
 300 #define MIB_DESC(_size, _offset, _name) {.size = _size, .offset = _offset, .name = _name}
 301
 302 static const struct gswip_rmon_cnt_desc gswip_rmon_cnt[] = {
 303         /** Receive Packet Count (only packets that are accepted and not discarded). */
 304         MIB_DESC(1, 0x1F, "RxGoodPkts"),
 305         MIB_DESC(1, 0x23, "RxUnicastPkts"),
 306         MIB_DESC(1, 0x22, "RxMulticastPkts"),
 307         MIB_DESC(1, 0x21, "RxFCSErrorPkts"),
 308         MIB_DESC(1, 0x1D, "RxUnderSizeGoodPkts"),
 309         MIB_DESC(1, 0x1E, "RxUnderSizeErrorPkts"),
 310         MIB_DESC(1, 0x1B, "RxOversizeGoodPkts"),
 311         MIB_DESC(1, 0x1C, "RxOversizeErrorPkts"),
 312         MIB_DESC(1, 0x20, "RxGoodPausePkts"),
 313         MIB_DESC(1, 0x1A, "RxAlignErrorPkts"),
 314         MIB_DESC(1, 0x12, "Rx64BytePkts"),
 315         MIB_DESC(1, 0x13, "Rx127BytePkts"),
 316         MIB_DESC(1, 0x14, "Rx255BytePkts"),
 317         MIB_DESC(1, 0x15, "Rx511BytePkts"),
 318         MIB_DESC(1, 0x16, "Rx1023BytePkts"),
 319         /** Receive Size 1024-1522 (or more, if configured) Packet Count. */
 320         MIB_DESC(1, 0x17, "RxMaxBytePkts"),
 321         MIB_DESC(1, 0x18, "RxDroppedPkts"),
 322         MIB_DESC(1, 0x19, "RxFilteredPkts"),
 323         MIB_DESC(2, 0x24, "RxGoodBytes"),
 324         MIB_DESC(2, 0x26, "RxBadBytes"),
 325         MIB_DESC(1, 0x11, "TxAcmDroppedPkts"),
 326         MIB_DESC(1, 0x0C, "TxGoodPkts"),
 327         MIB_DESC(1, 0x06, "TxUnicastPkts"),
 328         MIB_DESC(1, 0x07, "TxMulticastPkts"),
 329         MIB_DESC(1, 0x00, "Tx64BytePkts"),
 330         MIB_DESC(1, 0x01, "Tx127BytePkts"),
 331         MIB_DESC(1, 0x02, "Tx255BytePkts"),
 332         MIB_DESC(1, 0x03, "Tx511BytePkts"),
 333         MIB_DESC(1, 0x04, "Tx1023BytePkts"),
 334         /** Transmit Size 1024-1522 (or more, if configured) Packet Count. */
 335         MIB_DESC(1, 0x05, "TxMaxBytePkts"),
 336         MIB_DESC(1, 0x08, "TxSingleCollCount"),
 337         MIB_DESC(1, 0x09, "TxMultCollCount"),
 338         MIB_DESC(1, 0x0A, "TxLateCollCount"),
 339         MIB_DESC(1, 0x0B, "TxExcessCollCount"),
 340         MIB_DESC(1, 0x0D, "TxPauseCount"),
 341         MIB_DESC(1, 0x10, "TxDroppedPkts"),
 342         MIB_DESC(2, 0x0E, "TxGoodBytes"),
 343 };
 344
 345 static u32 gswip_switch_r(struct gswip_priv *priv, u32 offset)
 346 {
 347         return __raw_readl(priv->gswip + (offset * 4));
 348 }
 349
 350 static void gswip_switch_w(struct gswip_priv *priv, u32 val, u32 offset)
 351 {
 352         __raw_writel(val, priv->gswip + (offset * 4));
 353 }
 354
 355 static void gswip_switch_mask(struct gswip_priv *priv, u32 clear, u32 set,
 356                               u32 offset)
 357 {
 358         u32 val = gswip_switch_r(priv, offset);
 359
 360         val &= ~(clear);
 361         val |= set;
 362         gswip_switch_w(priv, val, offset);
 363 }
 364
 365 static u32 gswip_switch_r_timeout(struct gswip_priv *priv, u32 offset,
 366                                   u32 cleared)
 367 {
 368         u32 val;
 369
 370         return readx_poll_timeout(__raw_readl, priv->gswip + (offset * 4), val,
 371                                   (val & cleared) == 0, 20, 50000);
 372 }
 373
 374 static u32 gswip_mdio_r(struct gswip_priv *priv, u32 offset)
 375 {
 376         return __raw_readl(priv->mdio + (offset * 4));
 377 }
 378
 379 static void gswip_mdio_w(struct gswip_priv *priv, u32 val, u32 offset)
 380 {
 381         __raw_writel(val, priv->mdio + (offset * 4));
 382 }
 383
 384 static void gswip_mdio_mask(struct gswip_priv *priv, u32 clear, u32 set,
 385                             u32 offset)
 386 {
 387         u32 val = gswip_mdio_r(priv, offset);
 388
 389         val &= ~(clear);
 390         val |= set;
 391         gswip_mdio_w(priv, val, offset);
 392 }
 393
 394 static u32 gswip_mii_r(struct gswip_priv *priv, u32 offset)
 395 {
 396         return __raw_readl(priv->mii + (offset * 4));
 397 }
 398
 399 static void gswip_mii_w(struct gswip_priv *priv, u32 val, u32 offset)
 400 {
 401         __raw_writel(val, priv->mii + (offset * 4));
 402 }
 403
 404 static void gswip_mii_mask(struct gswip_priv *priv, u32 clear, u32 set,
 405                            u32 offset)
 406 {
 407         u32 val = gswip_mii_r(priv, offset);
 408
 409         val &= ~(clear);
 410         val |= set;
 411         gswip_mii_w(priv, val, offset);
 412 }
 413
 414 static void gswip_mii_mask_cfg(struct gswip_priv *priv, u32 clear, u32 set,
 415                                int port)
 416 {
 417         /* There's no MII_CFG register for the CPU port */
 418         if (!dsa_is_cpu_port(priv->ds, port))
 419                 gswip_mii_mask(priv, clear, set, GSWIP_MII_CFGp(port));
 420 }
 421
 422 static void gswip_mii_mask_pcdu(struct gswip_priv *priv, u32 clear, u32 set,
 423                                 int port)
 424 {
 425         switch (port) {
 426         case 0:
 427                 gswip_mii_mask(priv, clear, set, GSWIP_MII_PCDU0);
 428                 break;
 429         case 1:
 430                 gswip_mii_mask(priv, clear, set, GSWIP_MII_PCDU1);
 431                 break;
 432         case 5:
 433                 gswip_mii_mask(priv, clear, set, GSWIP_MII_PCDU5);
 434                 break;
 435         }
 436 }
 437
 438 static int gswip_mdio_poll(struct gswip_priv *priv)
 439 {
 440         int cnt = 100;
 441
 442         while (likely(cnt--)) {
 443                 u32 ctrl = gswip_mdio_r(priv, GSWIP_MDIO_CTRL);
 444
 445                 if ((ctrl & GSWIP_MDIO_CTRL_BUSY) == 0)
 446                         return 0;
 447                 usleep_range(20, 40);
 448         }
 449
 450         return -ETIMEDOUT;
 451 }
 452
 453 static int gswip_mdio_wr(struct mii_bus *bus, int addr, int reg, u16 val)
 454 {
 455         struct gswip_priv *priv = bus->priv;
 456         int err;
 457
 458         err = gswip_mdio_poll(priv);
 459         if (err) {
 460                 dev_err(&bus->dev, "waiting for MDIO bus busy timed out\n");
 461                 return err;
 462         }
 463
 464         gswip_mdio_w(priv, val, GSWIP_MDIO_WRITE);
 465         gswip_mdio_w(priv, GSWIP_MDIO_CTRL_BUSY | GSWIP_MDIO_CTRL_WR |
 466                 ((addr & GSWIP_MDIO_CTRL_PHYAD_MASK) << GSWIP_MDIO_CTRL_PHYAD_SHIFT) |
 467                 (reg & GSWIP_MDIO_CTRL_REGAD_MASK),
 468                 GSWIP_MDIO_CTRL);
 469
 470         return 0;
 471 }
 472
 473 static int gswip_mdio_rd(struct mii_bus *bus, int addr, int reg)
 474 {
 475         struct gswip_priv *priv = bus->priv;
 476         int err;
 477
 478         err = gswip_mdio_poll(priv);
 479         if (err) {
 480                 dev_err(&bus->dev, "waiting for MDIO bus busy timed out\n");
 481                 return err;
 482         }
 483
 484         gswip_mdio_w(priv, GSWIP_MDIO_CTRL_BUSY | GSWIP_MDIO_CTRL_RD |
 485                 ((addr & GSWIP_MDIO_CTRL_PHYAD_MASK) << GSWIP_MDIO_CTRL_PHYAD_SHIFT) |
 486                 (reg & GSWIP_MDIO_CTRL_REGAD_MASK),
 487                 GSWIP_MDIO_CTRL);
 488
 489         err = gswip_mdio_poll(priv);
 490         if (err) {
 491                 dev_err(&bus->dev, "waiting for MDIO bus busy timed out\n");
 492                 return err;
 493         }
 494
 495         return gswip_mdio_r(priv, GSWIP_MDIO_READ);
 496 }
 497
 498 static int gswip_mdio(struct gswip_priv *priv, struct device_node *mdio_np)
 499 {
 500         struct dsa_switch *ds = priv->ds;
 501         int err;
 502
 503         ds->slave_mii_bus = mdiobus_alloc();
 504         if (!ds->slave_mii_bus)
 505                 return -ENOMEM;
 506
 507         ds->slave_mii_bus->priv = priv;
 508         ds->slave_mii_bus->read = gswip_mdio_rd;
 509         ds->slave_mii_bus->write = gswip_mdio_wr;
 510         ds->slave_mii_bus->name = "lantiq,xrx200-mdio";
 511         snprintf(ds->slave_mii_bus->id, MII_BUS_ID_SIZE, "%s-mii",
 512                  dev_name(priv->dev));
 513         ds->slave_mii_bus->parent = priv->dev;
 514         ds->slave_mii_bus->phy_mask = ~ds->phys_mii_mask;
 515
 516         err = of_mdiobus_register(ds->slave_mii_bus, mdio_np);
 517         if (err)
 518                 mdiobus_free(ds->slave_mii_bus);
 519
 520         return err;
 521 }
 522
 523 static int gswip_pce_table_entry_read(struct gswip_priv *priv,
 524                                       struct gswip_pce_table_entry *tbl)
 525 {
 526         int i;
 527         int err;
 528         u16 crtl;
 529         u16 addr_mode = tbl->key_mode ? GSWIP_PCE_TBL_CTRL_OPMOD_KSRD :
 530                                         GSWIP_PCE_TBL_CTRL_OPMOD_ADRD;
 531
 532         mutex_lock(&priv->pce_table_lock);
 533
 534         err = gswip_switch_r_timeout(priv, GSWIP_PCE_TBL_CTRL,
 535                                      GSWIP_PCE_TBL_CTRL_BAS);
 536         if (err) {
 537                 mutex_unlock(&priv->pce_table_lock);
 538                 return err;
 539         }
 540
 541         gswip_switch_w(priv, tbl->index, GSWIP_PCE_TBL_ADDR);
 542         gswip_switch_mask(priv, GSWIP_PCE_TBL_CTRL_ADDR_MASK |
 543                                 GSWIP_PCE_TBL_CTRL_OPMOD_MASK,
 544                           tbl->table | addr_mode | GSWIP_PCE_TBL_CTRL_BAS,
 545                           GSWIP_PCE_TBL_CTRL);
 546
 547         err = gswip_switch_r_timeout(priv, GSWIP_PCE_TBL_CTRL,
 548                                      GSWIP_PCE_TBL_CTRL_BAS);
 549         if (err) {
 550                 mutex_unlock(&priv->pce_table_lock);
 551                 return err;
 552         }
 553
 554         for (i = 0; i < ARRAY_SIZE(tbl->key); i++)
 555                 tbl->key[i] = gswip_switch_r(priv, GSWIP_PCE_TBL_KEY(i));
 556
 557         for (i = 0; i < ARRAY_SIZE(tbl->val); i++)
 558                 tbl->val[i] = gswip_switch_r(priv, GSWIP_PCE_TBL_VAL(i));
 559
 560         tbl->mask = gswip_switch_r(priv, GSWIP_PCE_TBL_MASK);
 561
 562         crtl = gswip_switch_r(priv, GSWIP_PCE_TBL_CTRL);
 563
 564         tbl->type = !!(crtl & GSWIP_PCE_TBL_CTRL_TYPE);
 565         tbl->valid = !!(crtl & GSWIP_PCE_TBL_CTRL_VLD);
 566         tbl->gmap = (crtl & GSWIP_PCE_TBL_CTRL_GMAP_MASK) >> 7;
 567
 568         mutex_unlock(&priv->pce_table_lock);
 569
 570         return 0;
 571 }
 572
 573 static int gswip_pce_table_entry_write(struct gswip_priv *priv,
 574                                        struct gswip_pce_table_entry *tbl)
 575 {
 576         int i;
 577         int err;
 578         u16 crtl;
 579         u16 addr_mode = tbl->key_mode ? GSWIP_PCE_TBL_CTRL_OPMOD_KSWR :
 580                                         GSWIP_PCE_TBL_CTRL_OPMOD_ADWR;
 581
 582         mutex_lock(&priv->pce_table_lock);
 583
 584         err = gswip_switch_r_timeout(priv, GSWIP_PCE_TBL_CTRL,
 585                                      GSWIP_PCE_TBL_CTRL_BAS);
 586         if (err) {
 587                 mutex_unlock(&priv->pce_table_lock);
 588                 return err;
 589         }
 590
 591         gswip_switch_w(priv, tbl->index, GSWIP_PCE_TBL_ADDR);
 592         gswip_switch_mask(priv, GSWIP_PCE_TBL_CTRL_ADDR_MASK |
 593                                 GSWIP_PCE_TBL_CTRL_OPMOD_MASK,
 594                           tbl->table | addr_mode,
 595                           GSWIP_PCE_TBL_CTRL);
 596
 597         for (i = 0; i < ARRAY_SIZE(tbl->key); i++)
 598                 gswip_switch_w(priv, tbl->key[i], GSWIP_PCE_TBL_KEY(i));
 599
 600         for (i = 0; i < ARRAY_SIZE(tbl->val); i++)
 601                 gswip_switch_w(priv, tbl->val[i], GSWIP_PCE_TBL_VAL(i));
 602
 603         gswip_switch_mask(priv, GSWIP_PCE_TBL_CTRL_ADDR_MASK |
 604                                 GSWIP_PCE_TBL_CTRL_OPMOD_MASK,
 605                           tbl->table | addr_mode,
 606                           GSWIP_PCE_TBL_CTRL);
 607
 608         gswip_switch_w(priv, tbl->mask, GSWIP_PCE_TBL_MASK);
 609
 610         crtl = gswip_switch_r(priv, GSWIP_PCE_TBL_CTRL);
 611         crtl &= ~(GSWIP_PCE_TBL_CTRL_TYPE | GSWIP_PCE_TBL_CTRL_VLD |
 612                   GSWIP_PCE_TBL_CTRL_GMAP_MASK);
 613         if (tbl->type)
 614                 crtl |= GSWIP_PCE_TBL_CTRL_TYPE;
 615         if (tbl->valid)
 616                 crtl |= GSWIP_PCE_TBL_CTRL_VLD;
 617         crtl |= (tbl->gmap << 7) & GSWIP_PCE_TBL_CTRL_GMAP_MASK;
 618         crtl |= GSWIP_PCE_TBL_CTRL_BAS;
 619         gswip_switch_w(priv, crtl, GSWIP_PCE_TBL_CTRL);
 620
 621         err = gswip_switch_r_timeout(priv, GSWIP_PCE_TBL_CTRL,
 622                                      GSWIP_PCE_TBL_CTRL_BAS);
 623
 624         mutex_unlock(&priv->pce_table_lock);
 625
 626         return err;
 627 }
 628
 629 /* Add the LAN port into a bridge with the CPU port by
 630  * default. This prevents automatic forwarding of
 631  * packages between the LAN ports when no explicit
 632  * bridge is configured.
 633  */
 634 static int gswip_add_single_port_br(struct gswip_priv *priv, int port, bool add)
 635 {
 636         struct gswip_pce_table_entry vlan_active = {0,};
 637         struct gswip_pce_table_entry vlan_mapping = {0,};
 638         unsigned int cpu_port = priv->hw_info->cpu_port;
 639         unsigned int max_ports = priv->hw_info->max_ports;
 640         int err;
 641
 642         if (port >= max_ports) {
 643                 dev_err(priv->dev, "single port for %i supported\n", port);
 644                 return -EIO;
 645         }
 646
 647         vlan_active.index = port + 1;
 648         vlan_active.table = GSWIP_TABLE_ACTIVE_VLAN;
 649         vlan_active.key[0] = 0; /* vid */
 650         vlan_active.val[0] = port + 1 /* fid */;
 651         vlan_active.valid = add;
 652         err = gswip_pce_table_entry_write(priv, &vlan_active);
 653         if (err) {
 654                 dev_err(priv->dev, "failed to write active VLAN: %d\n", err);
 655                 return err;
 656         }
 657
 658         if (!add)
 659                 return 0;
 660
 661         vlan_mapping.index = port + 1;
 662         vlan_mapping.table = GSWIP_TABLE_VLAN_MAPPING;
 663         vlan_mapping.val[0] = 0 /* vid */;
 664         vlan_mapping.val[1] = BIT(port) | BIT(cpu_port);
 665         vlan_mapping.val[2] = 0;
 666         err = gswip_pce_table_entry_write(priv, &vlan_mapping);
 667         if (err) {
 668                 dev_err(priv->dev, "failed to write VLAN mapping: %d\n", err);
 669                 return err;
 670         }
 671
 672         return 0;
 673 }
 674
 675 static int gswip_port_enable(struct dsa_switch *ds, int port,
 676                              struct phy_device *phydev)
 677 {
 678         struct gswip_priv *priv = ds->priv;
 679         int err;
 680
 681         if (!dsa_is_user_port(ds, port))
 682                 return 0;
 683
 684         if (!dsa_is_cpu_port(ds, port)) {
 685                 err = gswip_add_single_port_br(priv, port, true);
 686                 if (err)
 687                         return err;
 688         }
 689
 690         /* RMON Counter Enable for port */
 691         gswip_switch_w(priv, GSWIP_BM_PCFG_CNTEN, GSWIP_BM_PCFGp(port));
 692
 693         /* enable port fetch/store dma & VLAN Modification */
 694         gswip_switch_mask(priv, 0, GSWIP_FDMA_PCTRL_EN |
 695                                    GSWIP_FDMA_PCTRL_VLANMOD_BOTH,
 696                          GSWIP_FDMA_PCTRLp(port));
 697         gswip_switch_mask(priv, 0, GSWIP_SDMA_PCTRL_EN,
 698                           GSWIP_SDMA_PCTRLp(port));
 699
 700         if (!dsa_is_cpu_port(ds, port)) {
 701                 u32 mdio_phy = 0;
 702
 703                 if (phydev)
 704                         mdio_phy = phydev->mdio.addr & GSWIP_MDIO_PHY_ADDR_MASK;
 705
 706                 gswip_mdio_mask(priv, GSWIP_MDIO_PHY_ADDR_MASK, mdio_phy,
 707                                 GSWIP_MDIO_PHYp(port));
 708         }
 709
 710         return 0;
 711 }
 712
 713 static void gswip_port_disable(struct dsa_switch *ds, int port)
 714 {
 715         struct gswip_priv *priv = ds->priv;
 716
 717         if (!dsa_is_user_port(ds, port))
 718                 return;
 719
 720         gswip_switch_mask(priv, GSWIP_FDMA_PCTRL_EN, 0,
 721                           GSWIP_FDMA_PCTRLp(port));
 722         gswip_switch_mask(priv, GSWIP_SDMA_PCTRL_EN, 0,
 723                           GSWIP_SDMA_PCTRLp(port));
 724 }
 725
 726 static int gswip_pce_load_microcode(struct gswip_priv *priv)
 727 {
 728         int i;
 729         int err;
 730
 731         gswip_switch_mask(priv, GSWIP_PCE_TBL_CTRL_ADDR_MASK |
 732                                 GSWIP_PCE_TBL_CTRL_OPMOD_MASK,
 733                           GSWIP_PCE_TBL_CTRL_OPMOD_ADWR, GSWIP_PCE_TBL_CTRL);
 734         gswip_switch_w(priv, 0, GSWIP_PCE_TBL_MASK);
 735
 736         for (i = 0; i < ARRAY_SIZE(gswip_pce_microcode); i++) {
 737                 gswip_switch_w(priv, i, GSWIP_PCE_TBL_ADDR);
 738                 gswip_switch_w(priv, gswip_pce_microcode[i].val_0,
 739                                GSWIP_PCE_TBL_VAL(0));
 740                 gswip_switch_w(priv, gswip_pce_microcode[i].val_1,
 741                                GSWIP_PCE_TBL_VAL(1));
 742                 gswip_switch_w(priv, gswip_pce_microcode[i].val_2,
 743                                GSWIP_PCE_TBL_VAL(2));
 744                 gswip_switch_w(priv, gswip_pce_microcode[i].val_3,
 745                                GSWIP_PCE_TBL_VAL(3));
 746
 747                 /* start the table access: */
 748                 gswip_switch_mask(priv, 0, GSWIP_PCE_TBL_CTRL_BAS,
 749                                   GSWIP_PCE_TBL_CTRL);
 750                 err = gswip_switch_r_timeout(priv, GSWIP_PCE_TBL_CTRL,
 751                                              GSWIP_PCE_TBL_CTRL_BAS);
 752                 if (err)
 753                         return err;
 754         }
 755
 756         /* tell the switch that the microcode is loaded */
 757         gswip_switch_mask(priv, 0, GSWIP_PCE_GCTRL_0_MC_VALID,
 758                           GSWIP_PCE_GCTRL_0);
 759
 760         return 0;
 761 }
 762
 763 static int gswip_port_vlan_filtering(struct dsa_switch *ds, int port,
 764                                      bool vlan_filtering,
 765                                      struct netlink_ext_ack *extack)
 766 {
 767         struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
 768         struct gswip_priv *priv = ds->priv;
 769
 770         /* Do not allow changing the VLAN filtering options while in bridge */
 771         if (bridge && !!(priv->port_vlan_filter & BIT(port)) != vlan_filtering) {
 772                 NL_SET_ERR_MSG_MOD(extack,
 773                                    "Dynamic toggling of vlan_filtering not supported");
 774                 return -EIO;
 775         }
 776
 777         if (vlan_filtering) {
 778                 /* Use port based VLAN tag */
 779                 gswip_switch_mask(priv,
 780                                   GSWIP_PCE_VCTRL_VSR,
 781                                   GSWIP_PCE_VCTRL_UVR | GSWIP_PCE_VCTRL_VIMR |
 782                                   GSWIP_PCE_VCTRL_VEMR,
 783                                   GSWIP_PCE_VCTRL(port));
 784                 gswip_switch_mask(priv, GSWIP_PCE_PCTRL_0_TVM, 0,
 785                                   GSWIP_PCE_PCTRL_0p(port));
 786         } else {
 787                 /* Use port based VLAN tag */
 788                 gswip_switch_mask(priv,
 789                                   GSWIP_PCE_VCTRL_UVR | GSWIP_PCE_VCTRL_VIMR |
 790                                   GSWIP_PCE_VCTRL_VEMR,
 791                                   GSWIP_PCE_VCTRL_VSR,
 792                                   GSWIP_PCE_VCTRL(port));
 793                 gswip_switch_mask(priv, 0, GSWIP_PCE_PCTRL_0_TVM,
 794                                   GSWIP_PCE_PCTRL_0p(port));
 795         }
 796
 797         return 0;
 798 }
 799
 800 static int gswip_setup(struct dsa_switch *ds)
 801 {
 802         struct gswip_priv *priv = ds->priv;
 803         unsigned int cpu_port = priv->hw_info->cpu_port;
 804         int i;
 805         int err;
 806
 807         gswip_switch_w(priv, GSWIP_SWRES_R0, GSWIP_SWRES);
 808         usleep_range(5000, 10000);
 809         gswip_switch_w(priv, 0, GSWIP_SWRES);
 810
 811         /* disable port fetch/store dma on all ports */
 812         for (i = 0; i < priv->hw_info->max_ports; i++) {
 813                 gswip_port_disable(ds, i);
 814                 gswip_port_vlan_filtering(ds, i, false, NULL);
 815         }
 816
 817         /* enable Switch */
 818         gswip_mdio_mask(priv, 0, GSWIP_MDIO_GLOB_ENABLE, GSWIP_MDIO_GLOB);
 819
 820         err = gswip_pce_load_microcode(priv);
 821         if (err) {
 822                 dev_err(priv->dev, "writing PCE microcode failed, %i", err);
 823                 return err;
 824         }
 825
 826         /* Default unknown Broadcast/Multicast/Unicast port maps */
 827         gswip_switch_w(priv, BIT(cpu_port), GSWIP_PCE_PMAP1);
 828         gswip_switch_w(priv, BIT(cpu_port), GSWIP_PCE_PMAP2);
 829         gswip_switch_w(priv, BIT(cpu_port), GSWIP_PCE_PMAP3);
 830
 831         /* Deactivate MDIO PHY auto polling. Some PHYs as the AR8030 have an
 832          * interoperability problem with this auto polling mechanism because
 833          * their status registers think that the link is in a different state
 834          * than it actually is. For the AR8030 it has the BMSR_ESTATEN bit set
 835          * as well as ESTATUS_1000_TFULL and ESTATUS_1000_XFULL. This makes the
 836          * auto polling state machine consider the link being negotiated with
 837          * 1Gbit/s. Since the PHY itself is a Fast Ethernet RMII PHY this leads
 838          * to the switch port being completely dead (RX and TX are both not
 839          * working).
 840          * Also with various other PHY / port combinations (PHY11G GPHY, PHY22F
 841          * GPHY, external RGMII PEF7071/7072) any traffic would stop. Sometimes
 842          * it would work fine for a few minutes to hours and then stop, on
 843          * other device it would no traffic could be sent or received at all.
 844          * Testing shows that when PHY auto polling is disabled these problems
 845          * go away.
 846          */
 847         gswip_mdio_w(priv, 0x0, GSWIP_MDIO_MDC_CFG0);
 848
 849         /* Configure the MDIO Clock 2.5 MHz */
 850         gswip_mdio_mask(priv, 0xff, 0x09, GSWIP_MDIO_MDC_CFG1);
 851
 852         /* Disable the xMII interface and clear it's isolation bit */
 853         for (i = 0; i < priv->hw_info->max_ports; i++)
 854                 gswip_mii_mask_cfg(priv,
 855                                    GSWIP_MII_CFG_EN | GSWIP_MII_CFG_ISOLATE,
 856                                    0, i);
 857
 858         /* enable special tag insertion on cpu port */
 859         gswip_switch_mask(priv, 0, GSWIP_FDMA_PCTRL_STEN,
 860                           GSWIP_FDMA_PCTRLp(cpu_port));
 861
 862         /* accept special tag in ingress direction */
 863         gswip_switch_mask(priv, 0, GSWIP_PCE_PCTRL_0_INGRESS,
 864                           GSWIP_PCE_PCTRL_0p(cpu_port));
 865
 866         gswip_switch_mask(priv, 0, GSWIP_MAC_CTRL_2_MLEN,
 867                           GSWIP_MAC_CTRL_2p(cpu_port));
 868         gswip_switch_w(priv, VLAN_ETH_FRAME_LEN + 8 + ETH_FCS_LEN,
 869                        GSWIP_MAC_FLEN);
 870         gswip_switch_mask(priv, 0, GSWIP_BM_QUEUE_GCTRL_GL_MOD,
 871                           GSWIP_BM_QUEUE_GCTRL);
 872
 873         /* VLAN aware Switching */
 874         gswip_switch_mask(priv, 0, GSWIP_PCE_GCTRL_0_VLAN, GSWIP_PCE_GCTRL_0);
 875
 876         /* Flush MAC Table */
 877         gswip_switch_mask(priv, 0, GSWIP_PCE_GCTRL_0_MTFL, GSWIP_PCE_GCTRL_0);
 878
 879         err = gswip_switch_r_timeout(priv, GSWIP_PCE_GCTRL_0,
 880                                      GSWIP_PCE_GCTRL_0_MTFL);
 881         if (err) {
 882                 dev_err(priv->dev, "MAC flushing didn't finish\n");
 883                 return err;
 884         }
 885
 886         gswip_port_enable(ds, cpu_port, NULL);
 887
 888         ds->configure_vlan_while_not_filtering = false;
 889
 890         return 0;
 891 }
 892
 893 static enum dsa_tag_protocol gswip_get_tag_protocol(struct dsa_switch *ds,
 894                                                     int port,
 895                                                     enum dsa_tag_protocol mp)
 896 {
 897         return DSA_TAG_PROTO_GSWIP;
 898 }
 899
 900 static int gswip_vlan_active_create(struct gswip_priv *priv,
 901                                     struct net_device *bridge,
 902                                     int fid, u16 vid)
 903 {
 904         struct gswip_pce_table_entry vlan_active = {0,};
 905         unsigned int max_ports = priv->hw_info->max_ports;
 906         int idx = -1;
 907         int err;
 908         int i;
 909
 910         /* Look for a free slot */
 911         for (i = max_ports; i < ARRAY_SIZE(priv->vlans); i++) {
 912                 if (!priv->vlans[i].bridge) {
 913                         idx = i;
 914                         break;
 915                 }
 916         }
 917
 918         if (idx == -1)
 919                 return -ENOSPC;
 920
 921         if (fid == -1)
 922                 fid = idx;
 923
 924         vlan_active.index = idx;
 925         vlan_active.table = GSWIP_TABLE_ACTIVE_VLAN;
 926         vlan_active.key[0] = vid;
 927         vlan_active.val[0] = fid;
 928         vlan_active.valid = true;
 929
 930         err = gswip_pce_table_entry_write(priv, &vlan_active);
 931         if (err) {
 932                 dev_err(priv->dev, "failed to write active VLAN: %d\n", err);
 933                 return err;
 934         }
 935
 936         priv->vlans[idx].bridge = bridge;
 937         priv->vlans[idx].vid = vid;
 938         priv->vlans[idx].fid = fid;
 939
 940         return idx;
 941 }
 942
 943 static int gswip_vlan_active_remove(struct gswip_priv *priv, int idx)
 944 {
 945         struct gswip_pce_table_entry vlan_active = {0,};
 946         int err;
 947
 948         vlan_active.index = idx;
 949         vlan_active.table = GSWIP_TABLE_ACTIVE_VLAN;
 950         vlan_active.valid = false;
 951         err = gswip_pce_table_entry_write(priv, &vlan_active);
 952         if (err)
 953                 dev_err(priv->dev, "failed to delete active VLAN: %d\n", err);
 954         priv->vlans[idx].bridge = NULL;
 955
 956         return err;
 957 }
 958
 959 static int gswip_vlan_add_unaware(struct gswip_priv *priv,
 960                                   struct net_device *bridge, int port)
 961 {
 962         struct gswip_pce_table_entry vlan_mapping = {0,};
 963         unsigned int max_ports = priv->hw_info->max_ports;
 964         unsigned int cpu_port = priv->hw_info->cpu_port;
 965         bool active_vlan_created = false;
 966         int idx = -1;
 967         int i;
 968         int err;
 969
 970         /* Check if there is already a page for this bridge */
 971         for (i = max_ports; i < ARRAY_SIZE(priv->vlans); i++) {
 972                 if (priv->vlans[i].bridge == bridge) {
 973                         idx = i;
 974                         break;
 975                 }
 976         }
 977
 978         /* If this bridge is not programmed yet, add a Active VLAN table
 979          * entry in a free slot and prepare the VLAN mapping table entry.
 980          */
 981         if (idx == -1) {
 982                 idx = gswip_vlan_active_create(priv, bridge, -1, 0);
 983                 if (idx < 0)
 984                         return idx;
 985                 active_vlan_created = true;
 986
 987                 vlan_mapping.index = idx;
 988                 vlan_mapping.table = GSWIP_TABLE_VLAN_MAPPING;
 989                 /* VLAN ID byte, maps to the VLAN ID of vlan active table */
 990                 vlan_mapping.val[0] = 0;
 991         } else {
 992                 /* Read the existing VLAN mapping entry from the switch */
 993                 vlan_mapping.index = idx;
 994                 vlan_mapping.table = GSWIP_TABLE_VLAN_MAPPING;
 995                 err = gswip_pce_table_entry_read(priv, &vlan_mapping);
 996                 if (err) {
 997                         dev_err(priv->dev, "failed to read VLAN mapping: %d\n",
 998                                 err);
 999                         return err;
1000                 }
1001         }
1002
1003         /* Update the VLAN mapping entry and write it to the switch */
1004         vlan_mapping.val[1] |= BIT(cpu_port);
1005         vlan_mapping.val[1] |= BIT(port);
1006         err = gswip_pce_table_entry_write(priv, &vlan_mapping);
1007         if (err) {
1008                 dev_err(priv->dev, "failed to write VLAN mapping: %d\n", err);
1009                 /* In case an Active VLAN was creaetd delete it again */
1010                 if (active_vlan_created)
1011                         gswip_vlan_active_remove(priv, idx);
1012                 return err;
1013         }
1014
1015         gswip_switch_w(priv, 0, GSWIP_PCE_DEFPVID(port));
1016         return 0;
1017 }
1018
1019 static int gswip_vlan_add_aware(struct gswip_priv *priv,
1020                                 struct net_device *bridge, int port,
1021                                 u16 vid, bool untagged,
1022                                 bool pvid)
1023 {
1024         struct gswip_pce_table_entry vlan_mapping = {0,};
1025         unsigned int max_ports = priv->hw_info->max_ports;
1026         unsigned int cpu_port = priv->hw_info->cpu_port;
1027         bool active_vlan_created = false;
1028         int idx = -1;
1029         int fid = -1;
1030         int i;
1031         int err;
1032
1033         /* Check if there is already a page for this bridge */
1034         for (i = max_ports; i < ARRAY_SIZE(priv->vlans); i++) {
1035                 if (priv->vlans[i].bridge == bridge) {
1036                         if (fid != -1 && fid != priv->vlans[i].fid)
1037                                 dev_err(priv->dev, "one bridge with multiple flow ids\n");
1038                         fid = priv->vlans[i].fid;
1039                         if (priv->vlans[i].vid == vid) {
1040                                 idx = i;
1041                                 break;
1042                         }
1043                 }
1044         }
1045
1046         /* If this bridge is not programmed yet, add a Active VLAN table
1047          * entry in a free slot and prepare the VLAN mapping table entry.
1048          */
1049         if (idx == -1) {
1050                 idx = gswip_vlan_active_create(priv, bridge, fid, vid);
1051                 if (idx < 0)
1052                         return idx;
1053                 active_vlan_created = true;
1054
1055                 vlan_mapping.index = idx;
1056                 vlan_mapping.table = GSWIP_TABLE_VLAN_MAPPING;
1057                 /* VLAN ID byte, maps to the VLAN ID of vlan active table */
1058                 vlan_mapping.val[0] = vid;
1059         } else {
1060                 /* Read the existing VLAN mapping entry from the switch */
1061                 vlan_mapping.index = idx;
1062                 vlan_mapping.table = GSWIP_TABLE_VLAN_MAPPING;
1063                 err = gswip_pce_table_entry_read(priv, &vlan_mapping);
1064                 if (err) {
1065                         dev_err(priv->dev, "failed to read VLAN mapping: %d\n",
1066                                 err);
1067                         return err;
1068                 }
1069         }
1070
1071         vlan_mapping.val[0] = vid;
1072         /* Update the VLAN mapping entry and write it to the switch */
1073         vlan_mapping.val[1] |= BIT(cpu_port);
1074         vlan_mapping.val[2] |= BIT(cpu_port);
1075         vlan_mapping.val[1] |= BIT(port);
1076         if (untagged)
1077                 vlan_mapping.val[2] &= ~BIT(port);
1078         else
1079                 vlan_mapping.val[2] |= BIT(port);
1080         err = gswip_pce_table_entry_write(priv, &vlan_mapping);
1081         if (err) {
1082                 dev_err(priv->dev, "failed to write VLAN mapping: %d\n", err);
1083                 /* In case an Active VLAN was creaetd delete it again */
1084                 if (active_vlan_created)
1085                         gswip_vlan_active_remove(priv, idx);
1086                 return err;
1087         }
1088
1089         if (pvid)
1090                 gswip_switch_w(priv, idx, GSWIP_PCE_DEFPVID(port));
1091
1092         return 0;
1093 }
1094
1095 static int gswip_vlan_remove(struct gswip_priv *priv,
1096                              struct net_device *bridge, int port,
1097                              u16 vid, bool pvid, bool vlan_aware)
1098 {
1099         struct gswip_pce_table_entry vlan_mapping = {0,};
1100         unsigned int max_ports = priv->hw_info->max_ports;
1101         unsigned int cpu_port = priv->hw_info->cpu_port;
1102         int idx = -1;
1103         int i;
1104         int err;
1105
1106         /* Check if there is already a page for this bridge */
1107         for (i = max_ports; i < ARRAY_SIZE(priv->vlans); i++) {
1108                 if (priv->vlans[i].bridge == bridge &&
1109                     (!vlan_aware || priv->vlans[i].vid == vid)) {
1110                         idx = i;
1111                         break;
1112                 }
1113         }
1114
1115         if (idx == -1) {
1116                 dev_err(priv->dev, "bridge to leave does not exists\n");
1117                 return -ENOENT;
1118         }
1119
1120         vlan_mapping.index = idx;
1121         vlan_mapping.table = GSWIP_TABLE_VLAN_MAPPING;
1122         err = gswip_pce_table_entry_read(priv, &vlan_mapping);
1123         if (err) {
1124                 dev_err(priv->dev, "failed to read VLAN mapping: %d\n", err);
1125                 return err;
1126         }
1127
1128         vlan_mapping.val[1] &= ~BIT(port);
1129         vlan_mapping.val[2] &= ~BIT(port);
1130         err = gswip_pce_table_entry_write(priv, &vlan_mapping);
1131         if (err) {
1132                 dev_err(priv->dev, "failed to write VLAN mapping: %d\n", err);
1133                 return err;
1134         }
1135
1136         /* In case all ports are removed from the bridge, remove the VLAN */
1137         if ((vlan_mapping.val[1] & ~BIT(cpu_port)) == 0) {
1138                 err = gswip_vlan_active_remove(priv, idx);
1139                 if (err) {
1140                         dev_err(priv->dev, "failed to write active VLAN: %d\n",
1141                                 err);
1142                         return err;
1143                 }
1144         }
1145
1146         /* GSWIP 2.2 (GRX300) and later program here the VID directly. */
1147         if (pvid)
1148                 gswip_switch_w(priv, 0, GSWIP_PCE_DEFPVID(port));
1149
1150         return 0;
1151 }
1152
1153 static int gswip_port_bridge_join(struct dsa_switch *ds, int port,
1154                                   struct dsa_bridge bridge,
1155                                   bool *tx_fwd_offload)
1156 {
1157         struct net_device *br = bridge.dev;
1158         struct gswip_priv *priv = ds->priv;
1159         int err;
1160
1161         /* When the bridge uses VLAN filtering we have to configure VLAN
1162          * specific bridges. No bridge is configured here.
1163          */
1164         if (!br_vlan_enabled(br)) {
1165                 err = gswip_vlan_add_unaware(priv, br, port);
1166                 if (err)
1167                         return err;
1168                 priv->port_vlan_filter &= ~BIT(port);
1169         } else {
1170                 priv->port_vlan_filter |= BIT(port);
1171         }
1172         return gswip_add_single_port_br(priv, port, false);
1173 }
1174
1175 static void gswip_port_bridge_leave(struct dsa_switch *ds, int port,
1176                                     struct dsa_bridge bridge)
1177 {
1178         struct net_device *br = bridge.dev;
1179         struct gswip_priv *priv = ds->priv;
1180
1181         gswip_add_single_port_br(priv, port, true);
1182
1183         /* When the bridge uses VLAN filtering we have to configure VLAN
1184          * specific bridges. No bridge is configured here.
1185          */
1186         if (!br_vlan_enabled(br))
1187                 gswip_vlan_remove(priv, br, port, 0, true, false);
1188 }
1189
1190 static int gswip_port_vlan_prepare(struct dsa_switch *ds, int port,
1191                                    const struct switchdev_obj_port_vlan *vlan,
1192                                    struct netlink_ext_ack *extack)
1193 {
1194         struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
1195         struct gswip_priv *priv = ds->priv;
1196         unsigned int max_ports = priv->hw_info->max_ports;
1197         int pos = max_ports;
1198         int i, idx = -1;
1199
1200         /* We only support VLAN filtering on bridges */
1201         if (!dsa_is_cpu_port(ds, port) && !bridge)
1202                 return -EOPNOTSUPP;
1203
1204         /* Check if there is already a page for this VLAN */
1205         for (i = max_ports; i < ARRAY_SIZE(priv->vlans); i++) {
1206                 if (priv->vlans[i].bridge == bridge &&
1207                     priv->vlans[i].vid == vlan->vid) {
1208                         idx = i;
1209                         break;
1210                 }
1211         }
1212
1213         /* If this VLAN is not programmed yet, we have to reserve
1214          * one entry in the VLAN table. Make sure we start at the
1215          * next position round.
1216          */
1217         if (idx == -1) {
1218                 /* Look for a free slot */
1219                 for (; pos < ARRAY_SIZE(priv->vlans); pos++) {
1220                         if (!priv->vlans[pos].bridge) {
1221                                 idx = pos;
1222                                 pos++;
1223                                 break;
1224                         }
1225                 }
1226
1227                 if (idx == -1) {
1228                         NL_SET_ERR_MSG_MOD(extack, "No slot in VLAN table");
1229                         return -ENOSPC;
1230                 }
1231         }
1232
1233         return 0;
1234 }
1235
1236 static int gswip_port_vlan_add(struct dsa_switch *ds, int port,
1237                                const struct switchdev_obj_port_vlan *vlan,
1238                                struct netlink_ext_ack *extack)
1239 {
1240         struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
1241         struct gswip_priv *priv = ds->priv;
1242         bool untagged = vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED;
1243         bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1244         int err;
1245
1246         err = gswip_port_vlan_prepare(ds, port, vlan, extack);
1247         if (err)
1248                 return err;
1249
1250         /* We have to receive all packets on the CPU port and should not
1251          * do any VLAN filtering here. This is also called with bridge
1252          * NULL and then we do not know for which bridge to configure
1253          * this.
1254          */
1255         if (dsa_is_cpu_port(ds, port))
1256                 return 0;
1257
1258         return gswip_vlan_add_aware(priv, bridge, port, vlan->vid,
1259                                     untagged, pvid);
1260 }
1261
1262 static int gswip_port_vlan_del(struct dsa_switch *ds, int port,
1263                                const struct switchdev_obj_port_vlan *vlan)
1264 {
1265         struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
1266         struct gswip_priv *priv = ds->priv;
1267         bool pvid = vlan->flags & BRIDGE_VLAN_INFO_PVID;
1268
1269         /* We have to receive all packets on the CPU port and should not
1270          * do any VLAN filtering here. This is also called with bridge
1271          * NULL and then we do not know for which bridge to configure
1272          * this.
1273          */
1274         if (dsa_is_cpu_port(ds, port))
1275                 return 0;
1276
1277         return gswip_vlan_remove(priv, bridge, port, vlan->vid, pvid, true);
1278 }
1279
1280 static void gswip_port_fast_age(struct dsa_switch *ds, int port)
1281 {
1282         struct gswip_priv *priv = ds->priv;
1283         struct gswip_pce_table_entry mac_bridge = {0,};
1284         int i;
1285         int err;
1286
1287         for (i = 0; i < 2048; i++) {
1288                 mac_bridge.table = GSWIP_TABLE_MAC_BRIDGE;
1289                 mac_bridge.index = i;
1290
1291                 err = gswip_pce_table_entry_read(priv, &mac_bridge);
1292                 if (err) {
1293                         dev_err(priv->dev, "failed to read mac bridge: %d\n",
1294                                 err);
1295                         return;
1296                 }
1297
1298                 if (!mac_bridge.valid)
1299                         continue;
1300
1301                 if (mac_bridge.val[1] & GSWIP_TABLE_MAC_BRIDGE_STATIC)
1302                         continue;
1303
1304                 if (((mac_bridge.val[0] & GENMASK(7, 4)) >> 4) != port)
1305                         continue;
1306
1307                 mac_bridge.valid = false;
1308                 err = gswip_pce_table_entry_write(priv, &mac_bridge);
1309                 if (err) {
1310                         dev_err(priv->dev, "failed to write mac bridge: %d\n",
1311                                 err);
1312                         return;
1313                 }
1314         }
1315 }
1316
1317 static void gswip_port_stp_state_set(struct dsa_switch *ds, int port, u8 state)
1318 {
1319         struct gswip_priv *priv = ds->priv;
1320         u32 stp_state;
1321
1322         switch (state) {
1323         case BR_STATE_DISABLED:
1324                 gswip_switch_mask(priv, GSWIP_SDMA_PCTRL_EN, 0,
1325                                   GSWIP_SDMA_PCTRLp(port));
1326                 return;
1327         case BR_STATE_BLOCKING:
1328         case BR_STATE_LISTENING:
1329                 stp_state = GSWIP_PCE_PCTRL_0_PSTATE_LISTEN;
1330                 break;
1331         case BR_STATE_LEARNING:
1332                 stp_state = GSWIP_PCE_PCTRL_0_PSTATE_LEARNING;
1333                 break;
1334         case BR_STATE_FORWARDING:
1335                 stp_state = GSWIP_PCE_PCTRL_0_PSTATE_FORWARDING;
1336                 break;
1337         default:
1338                 dev_err(priv->dev, "invalid STP state: %d\n", state);
1339                 return;
1340         }
1341
1342         gswip_switch_mask(priv, 0, GSWIP_SDMA_PCTRL_EN,
1343                           GSWIP_SDMA_PCTRLp(port));
1344         gswip_switch_mask(priv, GSWIP_PCE_PCTRL_0_PSTATE_MASK, stp_state,
1345                           GSWIP_PCE_PCTRL_0p(port));
1346 }
1347
1348 static int gswip_port_fdb(struct dsa_switch *ds, int port,
1349                           const unsigned char *addr, u16 vid, bool add)
1350 {
1351         struct net_device *bridge = dsa_port_bridge_dev_get(dsa_to_port(ds, port));
1352         struct gswip_priv *priv = ds->priv;
1353         struct gswip_pce_table_entry mac_bridge = {0,};
1354         unsigned int cpu_port = priv->hw_info->cpu_port;
1355         int fid = -1;
1356         int i;
1357         int err;
1358
1359         if (!bridge)
1360                 return -EINVAL;
1361
1362         for (i = cpu_port; i < ARRAY_SIZE(priv->vlans); i++) {
1363                 if (priv->vlans[i].bridge == bridge) {
1364                         fid = priv->vlans[i].fid;
1365                         break;
1366                 }
1367         }
1368
1369         if (fid == -1) {
1370                 dev_err(priv->dev, "Port not part of a bridge\n");
1371                 return -EINVAL;
1372         }
1373
1374         mac_bridge.table = GSWIP_TABLE_MAC_BRIDGE;
1375         mac_bridge.key_mode = true;
1376         mac_bridge.key[0] = addr[5] | (addr[4] << 8);
1377         mac_bridge.key[1] = addr[3] | (addr[2] << 8);
1378         mac_bridge.key[2] = addr[1] | (addr[0] << 8);
1379         mac_bridge.key[3] = fid;
1380         mac_bridge.val[0] = add ? BIT(port) : 0; /* port map */
1381         mac_bridge.val[1] = GSWIP_TABLE_MAC_BRIDGE_STATIC;
1382         mac_bridge.valid = add;
1383
1384         err = gswip_pce_table_entry_write(priv, &mac_bridge);
1385         if (err)
1386                 dev_err(priv->dev, "failed to write mac bridge: %d\n", err);
1387
1388         return err;
1389 }
1390
1391 static int gswip_port_fdb_add(struct dsa_switch *ds, int port,
1392                               const unsigned char *addr, u16 vid,
1393                               struct dsa_db db)
1394 {
1395         return gswip_port_fdb(ds, port, addr, vid, true);
1396 }
1397
1398 static int gswip_port_fdb_del(struct dsa_switch *ds, int port,
1399                               const unsigned char *addr, u16 vid,
1400                               struct dsa_db db)
1401 {
1402         return gswip_port_fdb(ds, port, addr, vid, false);
1403 }
1404
1405 static int gswip_port_fdb_dump(struct dsa_switch *ds, int port,
1406                                dsa_fdb_dump_cb_t *cb, void *data)
1407 {
1408         struct gswip_priv *priv = ds->priv;
1409         struct gswip_pce_table_entry mac_bridge = {0,};
1410         unsigned char addr[6];
1411         int i;
1412         int err;
1413
1414         for (i = 0; i < 2048; i++) {
1415                 mac_bridge.table = GSWIP_TABLE_MAC_BRIDGE;
1416                 mac_bridge.index = i;
1417
1418                 err = gswip_pce_table_entry_read(priv, &mac_bridge);
1419                 if (err) {
1420                         dev_err(priv->dev, "failed to write mac bridge: %d\n",
1421                                 err);
1422                         return err;
1423                 }
1424
1425                 if (!mac_bridge.valid)
1426                         continue;
1427
1428                 addr[5] = mac_bridge.key[0] & 0xff;
1429                 addr[4] = (mac_bridge.key[0] >> 8) & 0xff;
1430                 addr[3] = mac_bridge.key[1] & 0xff;
1431                 addr[2] = (mac_bridge.key[1] >> 8) & 0xff;
1432                 addr[1] = mac_bridge.key[2] & 0xff;
1433                 addr[0] = (mac_bridge.key[2] >> 8) & 0xff;
1434                 if (mac_bridge.val[1] & GSWIP_TABLE_MAC_BRIDGE_STATIC) {
1435                         if (mac_bridge.val[0] & BIT(port)) {
1436                                 err = cb(addr, 0, true, data);
1437                                 if (err)
1438                                         return err;
1439                         }
1440                 } else {
1441                         if (((mac_bridge.val[0] & GENMASK(7, 4)) >> 4) == port) {
1442                                 err = cb(addr, 0, false, data);
1443                                 if (err)
1444                                         return err;
1445                         }
1446                 }
1447         }
1448         return 0;
1449 }
1450
1451 static void gswip_xrx200_phylink_get_caps(struct dsa_switch *ds, int port,
1452                                           struct phylink_config *config)
1453 {
1454         switch (port) {
1455         case 0:
1456         case 1:
1457                 phy_interface_set_rgmii(config->supported_interfaces);
1458                 __set_bit(PHY_INTERFACE_MODE_MII,
1459                           config->supported_interfaces);
1460                 __set_bit(PHY_INTERFACE_MODE_REVMII,
1461                           config->supported_interfaces);
1462                 __set_bit(PHY_INTERFACE_MODE_RMII,
1463                           config->supported_interfaces);
1464                 break;
1465
1466         case 2:
1467         case 3:
1468         case 4:
1469                 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
1470                           config->supported_interfaces);
1471                 break;
1472
1473         case 5:
1474                 phy_interface_set_rgmii(config->supported_interfaces);
1475                 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
1476                           config->supported_interfaces);
1477                 break;
1478         }
1479
1480         config->mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |
1481                 MAC_10 | MAC_100 | MAC_1000;
1482 }
1483
1484 static void gswip_xrx300_phylink_get_caps(struct dsa_switch *ds, int port,
1485                                           struct phylink_config *config)
1486 {
1487         switch (port) {
1488         case 0:
1489                 phy_interface_set_rgmii(config->supported_interfaces);
1490                 __set_bit(PHY_INTERFACE_MODE_GMII,
1491                           config->supported_interfaces);
1492                 __set_bit(PHY_INTERFACE_MODE_RMII,
1493                           config->supported_interfaces);
1494                 break;
1495
1496         case 1:
1497         case 2:
1498         case 3:
1499         case 4:
1500                 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
1501                           config->supported_interfaces);
1502                 break;
1503
1504         case 5:
1505                 phy_interface_set_rgmii(config->supported_interfaces);
1506                 __set_bit(PHY_INTERFACE_MODE_INTERNAL,
1507                           config->supported_interfaces);
1508                 __set_bit(PHY_INTERFACE_MODE_RMII,
1509                           config->supported_interfaces);
1510                 break;
1511         }
1512
1513         config->mac_capabilities = MAC_ASYM_PAUSE | MAC_SYM_PAUSE |
1514                 MAC_10 | MAC_100 | MAC_1000;
1515 }
1516
1517 static void gswip_port_set_link(struct gswip_priv *priv, int port, bool link)
1518 {
1519         u32 mdio_phy;
1520
1521         if (link)
1522                 mdio_phy = GSWIP_MDIO_PHY_LINK_UP;
1523         else
1524                 mdio_phy = GSWIP_MDIO_PHY_LINK_DOWN;
1525
1526         gswip_mdio_mask(priv, GSWIP_MDIO_PHY_LINK_MASK, mdio_phy,
1527                         GSWIP_MDIO_PHYp(port));
1528 }
1529
1530 static void gswip_port_set_speed(struct gswip_priv *priv, int port, int speed,
1531                                  phy_interface_t interface)
1532 {
1533         u32 mdio_phy = 0, mii_cfg = 0, mac_ctrl_0 = 0;
1534
1535         switch (speed) {
1536         case SPEED_10:
1537                 mdio_phy = GSWIP_MDIO_PHY_SPEED_M10;
1538
1539                 if (interface == PHY_INTERFACE_MODE_RMII)
1540                         mii_cfg = GSWIP_MII_CFG_RATE_M50;
1541                 else
1542                         mii_cfg = GSWIP_MII_CFG_RATE_M2P5;
1543
1544                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_GMII_MII;
1545                 break;
1546
1547         case SPEED_100:
1548                 mdio_phy = GSWIP_MDIO_PHY_SPEED_M100;
1549
1550                 if (interface == PHY_INTERFACE_MODE_RMII)
1551                         mii_cfg = GSWIP_MII_CFG_RATE_M50;
1552                 else
1553                         mii_cfg = GSWIP_MII_CFG_RATE_M25;
1554
1555                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_GMII_MII;
1556                 break;
1557
1558         case SPEED_1000:
1559                 mdio_phy = GSWIP_MDIO_PHY_SPEED_G1;
1560
1561                 mii_cfg = GSWIP_MII_CFG_RATE_M125;
1562
1563                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_GMII_RGMII;
1564                 break;
1565         }
1566
1567         gswip_mdio_mask(priv, GSWIP_MDIO_PHY_SPEED_MASK, mdio_phy,
1568                         GSWIP_MDIO_PHYp(port));
1569         gswip_mii_mask_cfg(priv, GSWIP_MII_CFG_RATE_MASK, mii_cfg, port);
1570         gswip_switch_mask(priv, GSWIP_MAC_CTRL_0_GMII_MASK, mac_ctrl_0,
1571                           GSWIP_MAC_CTRL_0p(port));
1572 }
1573
1574 static void gswip_port_set_duplex(struct gswip_priv *priv, int port, int duplex)
1575 {
1576         u32 mac_ctrl_0, mdio_phy;
1577
1578         if (duplex == DUPLEX_FULL) {
1579                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_FDUP_EN;
1580                 mdio_phy = GSWIP_MDIO_PHY_FDUP_EN;
1581         } else {
1582                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_FDUP_DIS;
1583                 mdio_phy = GSWIP_MDIO_PHY_FDUP_DIS;
1584         }
1585
1586         gswip_switch_mask(priv, GSWIP_MAC_CTRL_0_FDUP_MASK, mac_ctrl_0,
1587                           GSWIP_MAC_CTRL_0p(port));
1588         gswip_mdio_mask(priv, GSWIP_MDIO_PHY_FDUP_MASK, mdio_phy,
1589                         GSWIP_MDIO_PHYp(port));
1590 }
1591
1592 static void gswip_port_set_pause(struct gswip_priv *priv, int port,
1593                                  bool tx_pause, bool rx_pause)
1594 {
1595         u32 mac_ctrl_0, mdio_phy;
1596
1597         if (tx_pause && rx_pause) {
1598                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_FCON_RXTX;
1599                 mdio_phy = GSWIP_MDIO_PHY_FCONTX_EN |
1600                            GSWIP_MDIO_PHY_FCONRX_EN;
1601         } else if (tx_pause) {
1602                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_FCON_TX;
1603                 mdio_phy = GSWIP_MDIO_PHY_FCONTX_EN |
1604                            GSWIP_MDIO_PHY_FCONRX_DIS;
1605         } else if (rx_pause) {
1606                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_FCON_RX;
1607                 mdio_phy = GSWIP_MDIO_PHY_FCONTX_DIS |
1608                            GSWIP_MDIO_PHY_FCONRX_EN;
1609         } else {
1610                 mac_ctrl_0 = GSWIP_MAC_CTRL_0_FCON_NONE;
1611                 mdio_phy = GSWIP_MDIO_PHY_FCONTX_DIS |
1612                            GSWIP_MDIO_PHY_FCONRX_DIS;
1613         }
1614
1615         gswip_switch_mask(priv, GSWIP_MAC_CTRL_0_FCON_MASK,
1616                           mac_ctrl_0, GSWIP_MAC_CTRL_0p(port));
1617         gswip_mdio_mask(priv,
1618                         GSWIP_MDIO_PHY_FCONTX_MASK |
1619                         GSWIP_MDIO_PHY_FCONRX_MASK,
1620                         mdio_phy, GSWIP_MDIO_PHYp(port));
1621 }
1622
1623 static void gswip_phylink_mac_config(struct dsa_switch *ds, int port,
1624                                      unsigned int mode,
1625                                      const struct phylink_link_state *state)
1626 {
1627         struct gswip_priv *priv = ds->priv;
1628         u32 miicfg = 0;
1629
1630         miicfg |= GSWIP_MII_CFG_LDCLKDIS;
1631
1632         switch (state->interface) {
1633         case PHY_INTERFACE_MODE_MII:
1634         case PHY_INTERFACE_MODE_INTERNAL:
1635                 miicfg |= GSWIP_MII_CFG_MODE_MIIM;
1636                 break;
1637         case PHY_INTERFACE_MODE_REVMII:
1638                 miicfg |= GSWIP_MII_CFG_MODE_MIIP;
1639                 break;
1640         case PHY_INTERFACE_MODE_RMII:
1641                 miicfg |= GSWIP_MII_CFG_MODE_RMIIM;
1642
1643                 /* Configure the RMII clock as output: */
1644                 miicfg |= GSWIP_MII_CFG_RMII_CLK;
1645                 break;
1646         case PHY_INTERFACE_MODE_RGMII:
1647         case PHY_INTERFACE_MODE_RGMII_ID:
1648         case PHY_INTERFACE_MODE_RGMII_RXID:
1649         case PHY_INTERFACE_MODE_RGMII_TXID:
1650                 miicfg |= GSWIP_MII_CFG_MODE_RGMII;
1651                 break;
1652         case PHY_INTERFACE_MODE_GMII:
1653                 miicfg |= GSWIP_MII_CFG_MODE_GMII;
1654                 break;
1655         default:
1656                 dev_err(ds->dev,
1657                         "Unsupported interface: %d\n", state->interface);
1658                 return;
1659         }
1660
1661         gswip_mii_mask_cfg(priv,
1662                            GSWIP_MII_CFG_MODE_MASK | GSWIP_MII_CFG_RMII_CLK |
1663                            GSWIP_MII_CFG_RGMII_IBS | GSWIP_MII_CFG_LDCLKDIS,
1664                            miicfg, port);
1665
1666         switch (state->interface) {
1667         case PHY_INTERFACE_MODE_RGMII_ID:
1668                 gswip_mii_mask_pcdu(priv, GSWIP_MII_PCDU_TXDLY_MASK |
1669                                           GSWIP_MII_PCDU_RXDLY_MASK, 0, port);
1670                 break;
1671         case PHY_INTERFACE_MODE_RGMII_RXID:
1672                 gswip_mii_mask_pcdu(priv, GSWIP_MII_PCDU_RXDLY_MASK, 0, port);
1673                 break;
1674         case PHY_INTERFACE_MODE_RGMII_TXID:
1675                 gswip_mii_mask_pcdu(priv, GSWIP_MII_PCDU_TXDLY_MASK, 0, port);
1676                 break;
1677         default:
1678                 break;
1679         }
1680 }
1681
1682 static void gswip_phylink_mac_link_down(struct dsa_switch *ds, int port,
1683                                         unsigned int mode,
1684                                         phy_interface_t interface)
1685 {
1686         struct gswip_priv *priv = ds->priv;
1687
1688         gswip_mii_mask_cfg(priv, GSWIP_MII_CFG_EN, 0, port);
1689
1690         if (!dsa_is_cpu_port(ds, port))
1691                 gswip_port_set_link(priv, port, false);
1692 }
1693
1694 static void gswip_phylink_mac_link_up(struct dsa_switch *ds, int port,
1695                                       unsigned int mode,
1696                                       phy_interface_t interface,
1697                                       struct phy_device *phydev,
1698                                       int speed, int duplex,
1699                                       bool tx_pause, bool rx_pause)
1700 {
1701         struct gswip_priv *priv = ds->priv;
1702
1703         if (!dsa_is_cpu_port(ds, port)) {
1704                 gswip_port_set_link(priv, port, true);
1705                 gswip_port_set_speed(priv, port, speed, interface);
1706                 gswip_port_set_duplex(priv, port, duplex);
1707                 gswip_port_set_pause(priv, port, tx_pause, rx_pause);
1708         }
1709
1710         gswip_mii_mask_cfg(priv, 0, GSWIP_MII_CFG_EN, port);
1711 }
1712
1713 static void gswip_get_strings(struct dsa_switch *ds, int port, u32 stringset,
1714                               uint8_t *data)
1715 {
1716         int i;
1717
1718         if (stringset != ETH_SS_STATS)
1719                 return;
1720
1721         for (i = 0; i < ARRAY_SIZE(gswip_rmon_cnt); i++)
1722                 strncpy(data + i * ETH_GSTRING_LEN, gswip_rmon_cnt[i].name,
1723                         ETH_GSTRING_LEN);
1724 }
1725
1726 static u32 gswip_bcm_ram_entry_read(struct gswip_priv *priv, u32 table,
1727                                     u32 index)
1728 {
1729         u32 result;
1730         int err;
1731
1732         gswip_switch_w(priv, index, GSWIP_BM_RAM_ADDR);
1733         gswip_switch_mask(priv, GSWIP_BM_RAM_CTRL_ADDR_MASK |
1734                                 GSWIP_BM_RAM_CTRL_OPMOD,
1735                               table | GSWIP_BM_RAM_CTRL_BAS,
1736                               GSWIP_BM_RAM_CTRL);
1737
1738         err = gswip_switch_r_timeout(priv, GSWIP_BM_RAM_CTRL,
1739                                      GSWIP_BM_RAM_CTRL_BAS);
1740         if (err) {
1741                 dev_err(priv->dev, "timeout while reading table: %u, index: %u",
1742                         table, index);
1743                 return 0;
1744         }
1745
1746         result = gswip_switch_r(priv, GSWIP_BM_RAM_VAL(0));
1747         result |= gswip_switch_r(priv, GSWIP_BM_RAM_VAL(1)) << 16;
1748
1749         return result;
1750 }
1751
1752 static void gswip_get_ethtool_stats(struct dsa_switch *ds, int port,
1753                                     uint64_t *data)
1754 {
1755         struct gswip_priv *priv = ds->priv;
1756         const struct gswip_rmon_cnt_desc *rmon_cnt;
1757         int i;
1758         u64 high;
1759
1760         for (i = 0; i < ARRAY_SIZE(gswip_rmon_cnt); i++) {
1761                 rmon_cnt = &gswip_rmon_cnt[i];
1762
1763                 data[i] = gswip_bcm_ram_entry_read(priv, port,
1764                                                    rmon_cnt->offset);
1765                 if (rmon_cnt->size == 2) {
1766                         high = gswip_bcm_ram_entry_read(priv, port,
1767                                                         rmon_cnt->offset + 1);
1768                         data[i] |= high << 32;
1769                 }
1770         }
1771 }
1772
1773 static int gswip_get_sset_count(struct dsa_switch *ds, int port, int sset)
1774 {
1775         if (sset != ETH_SS_STATS)
1776                 return 0;
1777
1778         return ARRAY_SIZE(gswip_rmon_cnt);
1779 }
1780
1781 static const struct dsa_switch_ops gswip_xrx200_switch_ops = {
1782         .get_tag_protocol       = gswip_get_tag_protocol,
1783         .setup                  = gswip_setup,
1784         .port_enable            = gswip_port_enable,
1785         .port_disable           = gswip_port_disable,
1786         .port_bridge_join       = gswip_port_bridge_join,
1787         .port_bridge_leave      = gswip_port_bridge_leave,
1788         .port_fast_age          = gswip_port_fast_age,
1789         .port_vlan_filtering    = gswip_port_vlan_filtering,
1790         .port_vlan_add          = gswip_port_vlan_add,
1791         .port_vlan_del          = gswip_port_vlan_del,
1792         .port_stp_state_set     = gswip_port_stp_state_set,
1793         .port_fdb_add           = gswip_port_fdb_add,
1794         .port_fdb_del           = gswip_port_fdb_del,
1795         .port_fdb_dump          = gswip_port_fdb_dump,
1796         .phylink_get_caps       = gswip_xrx200_phylink_get_caps,
1797         .phylink_mac_config     = gswip_phylink_mac_config,
1798         .phylink_mac_link_down  = gswip_phylink_mac_link_down,
1799         .phylink_mac_link_up    = gswip_phylink_mac_link_up,
1800         .get_strings            = gswip_get_strings,
1801         .get_ethtool_stats      = gswip_get_ethtool_stats,
1802         .get_sset_count         = gswip_get_sset_count,
1803 };
1804
1805 static const struct dsa_switch_ops gswip_xrx300_switch_ops = {
1806         .get_tag_protocol       = gswip_get_tag_protocol,
1807         .setup                  = gswip_setup,
1808         .port_enable            = gswip_port_enable,
1809         .port_disable           = gswip_port_disable,
1810         .port_bridge_join       = gswip_port_bridge_join,
1811         .port_bridge_leave      = gswip_port_bridge_leave,
1812         .port_fast_age          = gswip_port_fast_age,
1813         .port_vlan_filtering    = gswip_port_vlan_filtering,
1814         .port_vlan_add          = gswip_port_vlan_add,
1815         .port_vlan_del          = gswip_port_vlan_del,
1816         .port_stp_state_set     = gswip_port_stp_state_set,
1817         .port_fdb_add           = gswip_port_fdb_add,
1818         .port_fdb_del           = gswip_port_fdb_del,
1819         .port_fdb_dump          = gswip_port_fdb_dump,
1820         .phylink_get_caps       = gswip_xrx300_phylink_get_caps,
1821         .phylink_mac_config     = gswip_phylink_mac_config,
1822         .phylink_mac_link_down  = gswip_phylink_mac_link_down,
1823         .phylink_mac_link_up    = gswip_phylink_mac_link_up,
1824         .get_strings            = gswip_get_strings,
1825         .get_ethtool_stats      = gswip_get_ethtool_stats,
1826         .get_sset_count         = gswip_get_sset_count,
1827 };
1828
1829 static const struct xway_gphy_match_data xrx200a1x_gphy_data = {
1830         .fe_firmware_name = "lantiq/xrx200_phy22f_a14.bin",
1831         .ge_firmware_name = "lantiq/xrx200_phy11g_a14.bin",
1832 };
1833
1834 static const struct xway_gphy_match_data xrx200a2x_gphy_data = {
1835         .fe_firmware_name = "lantiq/xrx200_phy22f_a22.bin",
1836         .ge_firmware_name = "lantiq/xrx200_phy11g_a22.bin",
1837 };
1838
1839 static const struct xway_gphy_match_data xrx300_gphy_data = {
1840         .fe_firmware_name = "lantiq/xrx300_phy22f_a21.bin",
1841         .ge_firmware_name = "lantiq/xrx300_phy11g_a21.bin",
1842 };
1843
1844 static const struct of_device_id xway_gphy_match[] = {
1845         { .compatible = "lantiq,xrx200-gphy-fw", .data = NULL },
1846         { .compatible = "lantiq,xrx200a1x-gphy-fw", .data = &xrx200a1x_gphy_data },
1847         { .compatible = "lantiq,xrx200a2x-gphy-fw", .data = &xrx200a2x_gphy_data },
1848         { .compatible = "lantiq,xrx300-gphy-fw", .data = &xrx300_gphy_data },
1849         { .compatible = "lantiq,xrx330-gphy-fw", .data = &xrx300_gphy_data },
1850         {},
1851 };
1852
1853 static int gswip_gphy_fw_load(struct gswip_priv *priv, struct gswip_gphy_fw *gphy_fw)
1854 {
1855         struct device *dev = priv->dev;
1856         const struct firmware *fw;
1857         void *fw_addr;
1858         dma_addr_t dma_addr;
1859         dma_addr_t dev_addr;
1860         size_t size;
1861         int ret;
1862
1863         ret = clk_prepare_enable(gphy_fw->clk_gate);
1864         if (ret)
1865                 return ret;
1866
1867         reset_control_assert(gphy_fw->reset);
1868
1869         /* The vendor BSP uses a 200ms delay after asserting the reset line.
1870          * Without this some users are observing that the PHY is not coming up
1871          * on the MDIO bus.
1872          */
1873         msleep(200);
1874
1875         ret = request_firmware(&fw, gphy_fw->fw_name, dev);
1876         if (ret) {
1877                 dev_err(dev, "failed to load firmware: %s, error: %i\n",
1878                         gphy_fw->fw_name, ret);
1879                 return ret;
1880         }
1881
1882         /* GPHY cores need the firmware code in a persistent and contiguous
1883          * memory area with a 16 kB boundary aligned start address.
1884          */
1885         size = fw->size + XRX200_GPHY_FW_ALIGN;
1886
1887         fw_addr = dmam_alloc_coherent(dev, size, &dma_addr, GFP_KERNEL);
1888         if (fw_addr) {
1889                 fw_addr = PTR_ALIGN(fw_addr, XRX200_GPHY_FW_ALIGN);
1890                 dev_addr = ALIGN(dma_addr, XRX200_GPHY_FW_ALIGN);
1891                 memcpy(fw_addr, fw->data, fw->size);
1892         } else {
1893                 dev_err(dev, "failed to alloc firmware memory\n");
1894                 release_firmware(fw);
1895                 return -ENOMEM;
1896         }
1897
1898         release_firmware(fw);
1899
1900         ret = regmap_write(priv->rcu_regmap, gphy_fw->fw_addr_offset, dev_addr);
1901         if (ret)
1902                 return ret;
1903
1904         reset_control_deassert(gphy_fw->reset);
1905
1906         return ret;
1907 }
1908
1909 static int gswip_gphy_fw_probe(struct gswip_priv *priv,
1910                                struct gswip_gphy_fw *gphy_fw,
1911                                struct device_node *gphy_fw_np, int i)
1912 {
1913         struct device *dev = priv->dev;
1914         u32 gphy_mode;
1915         int ret;
1916         char gphyname[10];
1917
1918         snprintf(gphyname, sizeof(gphyname), "gphy%d", i);
1919
1920         gphy_fw->clk_gate = devm_clk_get(dev, gphyname);
1921         if (IS_ERR(gphy_fw->clk_gate)) {
1922                 dev_err(dev, "Failed to lookup gate clock\n");
1923                 return PTR_ERR(gphy_fw->clk_gate);
1924         }
1925
1926         ret = of_property_read_u32(gphy_fw_np, "reg", &gphy_fw->fw_addr_offset);
1927         if (ret)
1928                 return ret;
1929
1930         ret = of_property_read_u32(gphy_fw_np, "lantiq,gphy-mode", &gphy_mode);
1931         /* Default to GE mode */
1932         if (ret)
1933                 gphy_mode = GPHY_MODE_GE;
1934
1935         switch (gphy_mode) {
1936         case GPHY_MODE_FE:
1937                 gphy_fw->fw_name = priv->gphy_fw_name_cfg->fe_firmware_name;
1938                 break;
1939         case GPHY_MODE_GE:
1940                 gphy_fw->fw_name = priv->gphy_fw_name_cfg->ge_firmware_name;
1941                 break;
1942         default:
1943                 dev_err(dev, "Unknown GPHY mode %d\n", gphy_mode);
1944                 return -EINVAL;
1945         }
1946
1947         gphy_fw->reset = of_reset_control_array_get_exclusive(gphy_fw_np);
1948         if (IS_ERR(gphy_fw->reset)) {
1949                 if (PTR_ERR(gphy_fw->reset) != -EPROBE_DEFER)
1950                         dev_err(dev, "Failed to lookup gphy reset\n");
1951                 return PTR_ERR(gphy_fw->reset);
1952         }
1953
1954         return gswip_gphy_fw_load(priv, gphy_fw);
1955 }
1956
1957 static void gswip_gphy_fw_remove(struct gswip_priv *priv,
1958                                  struct gswip_gphy_fw *gphy_fw)
1959 {
1960         int ret;
1961
1962         /* check if the device was fully probed */
1963         if (!gphy_fw->fw_name)
1964                 return;
1965
1966         ret = regmap_write(priv->rcu_regmap, gphy_fw->fw_addr_offset, 0);
1967         if (ret)
1968                 dev_err(priv->dev, "can not reset GPHY FW pointer");
1969
1970         clk_disable_unprepare(gphy_fw->clk_gate);
1971
1972         reset_control_put(gphy_fw->reset);
1973 }
1974
1975 static int gswip_gphy_fw_list(struct gswip_priv *priv,
1976                               struct device_node *gphy_fw_list_np, u32 version)
1977 {
1978         struct device *dev = priv->dev;
1979         struct device_node *gphy_fw_np;
1980         const struct of_device_id *match;
1981         int err;
1982         int i = 0;
1983
1984         /* The VRX200 rev 1.1 uses the GSWIP 2.0 and needs the older
1985          * GPHY firmware. The VRX200 rev 1.2 uses the GSWIP 2.1 and also
1986          * needs a different GPHY firmware.
1987          */
1988         if (of_device_is_compatible(gphy_fw_list_np, "lantiq,xrx200-gphy-fw")) {
1989                 switch (version) {
1990                 case GSWIP_VERSION_2_0:
1991                         priv->gphy_fw_name_cfg = &xrx200a1x_gphy_data;
1992                         break;
1993                 case GSWIP_VERSION_2_1:
1994                         priv->gphy_fw_name_cfg = &xrx200a2x_gphy_data;
1995                         break;
1996                 default:
1997                         dev_err(dev, "unknown GSWIP version: 0x%x", version);
1998                         return -ENOENT;
1999                 }
2000         }
2001
2002         match = of_match_node(xway_gphy_match, gphy_fw_list_np);
2003         if (match && match->data)
2004                 priv->gphy_fw_name_cfg = match->data;
2005
2006         if (!priv->gphy_fw_name_cfg) {
2007                 dev_err(dev, "GPHY compatible type not supported");
2008                 return -ENOENT;
2009         }
2010
2011         priv->num_gphy_fw = of_get_available_child_count(gphy_fw_list_np);
2012         if (!priv->num_gphy_fw)
2013                 return -ENOENT;
2014
2015         priv->rcu_regmap = syscon_regmap_lookup_by_phandle(gphy_fw_list_np,
2016                                                            "lantiq,rcu");
2017         if (IS_ERR(priv->rcu_regmap))
2018                 return PTR_ERR(priv->rcu_regmap);
2019
2020         priv->gphy_fw = devm_kmalloc_array(dev, priv->num_gphy_fw,
2021                                            sizeof(*priv->gphy_fw),
2022                                            GFP_KERNEL | __GFP_ZERO);
2023         if (!priv->gphy_fw)
2024                 return -ENOMEM;
2025
2026         for_each_available_child_of_node(gphy_fw_list_np, gphy_fw_np) {
2027                 err = gswip_gphy_fw_probe(priv, &priv->gphy_fw[i],
2028                                           gphy_fw_np, i);
2029                 if (err)
2030                         goto remove_gphy;
2031                 i++;
2032         }
2033
2034         /* The standalone PHY11G requires 300ms to be fully
2035          * initialized and ready for any MDIO communication after being
2036          * taken out of reset. For the SoC-internal GPHY variant there
2037          * is no (known) documentation for the minimum time after a
2038          * reset. Use the same value as for the standalone variant as
2039          * some users have reported internal PHYs not being detected
2040          * without any delay.
2041          */
2042         msleep(300);
2043
2044         return 0;
2045
2046 remove_gphy:
2047         for (i = 0; i < priv->num_gphy_fw; i++)
2048                 gswip_gphy_fw_remove(priv, &priv->gphy_fw[i]);
2049         return err;
2050 }
2051
2052 static int gswip_probe(struct platform_device *pdev)
2053 {
2054         struct gswip_priv *priv;
2055         struct device_node *np, *mdio_np, *gphy_fw_np;
2056         struct device *dev = &pdev->dev;
2057         int err;
2058         int i;
2059         u32 version;
2060
2061         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
2062         if (!priv)
2063                 return -ENOMEM;
2064
2065         priv->gswip = devm_platform_ioremap_resource(pdev, 0);
2066         if (IS_ERR(priv->gswip))
2067                 return PTR_ERR(priv->gswip);
2068
2069         priv->mdio = devm_platform_ioremap_resource(pdev, 1);
2070         if (IS_ERR(priv->mdio))
2071                 return PTR_ERR(priv->mdio);
2072
2073         priv->mii = devm_platform_ioremap_resource(pdev, 2);
2074         if (IS_ERR(priv->mii))
2075                 return PTR_ERR(priv->mii);
2076
2077         priv->hw_info = of_device_get_match_data(dev);
2078         if (!priv->hw_info)
2079                 return -EINVAL;
2080
2081         priv->ds = devm_kzalloc(dev, sizeof(*priv->ds), GFP_KERNEL);
2082         if (!priv->ds)
2083                 return -ENOMEM;
2084
2085         priv->ds->dev = dev;
2086         priv->ds->num_ports = priv->hw_info->max_ports;
2087         priv->ds->priv = priv;
2088         priv->ds->ops = priv->hw_info->ops;
2089         priv->dev = dev;
2090         mutex_init(&priv->pce_table_lock);
2091         version = gswip_switch_r(priv, GSWIP_VERSION);
2092
2093         np = dev->of_node;
2094         switch (version) {
2095         case GSWIP_VERSION_2_0:
2096         case GSWIP_VERSION_2_1:
2097                 if (!of_device_is_compatible(np, "lantiq,xrx200-gswip"))
2098                         return -EINVAL;
2099                 break;
2100         case GSWIP_VERSION_2_2:
2101         case GSWIP_VERSION_2_2_ETC:
2102                 if (!of_device_is_compatible(np, "lantiq,xrx300-gswip") &&
2103                     !of_device_is_compatible(np, "lantiq,xrx330-gswip"))
2104                         return -EINVAL;
2105                 break;
2106         default:
2107                 dev_err(dev, "unknown GSWIP version: 0x%x", version);
2108                 return -ENOENT;
2109         }
2110
2111         /* bring up the mdio bus */
2112         gphy_fw_np = of_get_compatible_child(dev->of_node, "lantiq,gphy-fw");
2113         if (gphy_fw_np) {
2114                 err = gswip_gphy_fw_list(priv, gphy_fw_np, version);
2115                 of_node_put(gphy_fw_np);
2116                 if (err) {
2117                         dev_err(dev, "gphy fw probe failed\n");
2118                         return err;
2119                 }
2120         }
2121
2122         /* bring up the mdio bus */
2123         mdio_np = of_get_compatible_child(dev->of_node, "lantiq,xrx200-mdio");
2124         if (mdio_np) {
2125                 err = gswip_mdio(priv, mdio_np);
2126                 if (err) {
2127                         dev_err(dev, "mdio probe failed\n");
2128                         goto put_mdio_node;
2129                 }
2130         }
2131
2132         err = dsa_register_switch(priv->ds);
2133         if (err) {
2134                 dev_err(dev, "dsa switch register failed: %i\n", err);
2135                 goto mdio_bus;
2136         }
2137         if (!dsa_is_cpu_port(priv->ds, priv->hw_info->cpu_port)) {
2138                 dev_err(dev, "wrong CPU port defined, HW only supports port: %i",
2139                         priv->hw_info->cpu_port);
2140                 err = -EINVAL;
2141                 goto disable_switch;
2142         }
2143
2144         platform_set_drvdata(pdev, priv);
2145
2146         dev_info(dev, "probed GSWIP version %lx mod %lx\n",
2147                  (version & GSWIP_VERSION_REV_MASK) >> GSWIP_VERSION_REV_SHIFT,
2148                  (version & GSWIP_VERSION_MOD_MASK) >> GSWIP_VERSION_MOD_SHIFT);
2149         return 0;
2150
2151 disable_switch:
2152         gswip_mdio_mask(priv, GSWIP_MDIO_GLOB_ENABLE, 0, GSWIP_MDIO_GLOB);
2153         dsa_unregister_switch(priv->ds);
2154 mdio_bus:
2155         if (mdio_np) {
2156                 mdiobus_unregister(priv->ds->slave_mii_bus);
2157                 mdiobus_free(priv->ds->slave_mii_bus);
2158         }
2159 put_mdio_node:
2160         of_node_put(mdio_np);
2161         for (i = 0; i < priv->num_gphy_fw; i++)
2162                 gswip_gphy_fw_remove(priv, &priv->gphy_fw[i]);
2163         return err;
2164 }
2165
2166 static int gswip_remove(struct platform_device *pdev)
2167 {
2168         struct gswip_priv *priv = platform_get_drvdata(pdev);
2169         int i;
2170
2171         if (!priv)
2172                 return 0;
2173
2174         /* disable the switch */
2175         gswip_mdio_mask(priv, GSWIP_MDIO_GLOB_ENABLE, 0, GSWIP_MDIO_GLOB);
2176
2177         dsa_unregister_switch(priv->ds);
2178
2179         if (priv->ds->slave_mii_bus) {
2180                 mdiobus_unregister(priv->ds->slave_mii_bus);
2181                 of_node_put(priv->ds->slave_mii_bus->dev.of_node);
2182                 mdiobus_free(priv->ds->slave_mii_bus);
2183         }
2184
2185         for (i = 0; i < priv->num_gphy_fw; i++)
2186                 gswip_gphy_fw_remove(priv, &priv->gphy_fw[i]);
2187
2188         platform_set_drvdata(pdev, NULL);
2189
2190         return 0;
2191 }
2192
2193 static void gswip_shutdown(struct platform_device *pdev)
2194 {
2195         struct gswip_priv *priv = platform_get_drvdata(pdev);
2196
2197         if (!priv)
2198                 return;
2199
2200         dsa_switch_shutdown(priv->ds);
2201
2202         platform_set_drvdata(pdev, NULL);
2203 }
2204
2205 static const struct gswip_hw_info gswip_xrx200 = {
2206         .max_ports = 7,
2207         .cpu_port = 6,
2208         .ops = &gswip_xrx200_switch_ops,
2209 };
2210
2211 static const struct gswip_hw_info gswip_xrx300 = {
2212         .max_ports = 7,
2213         .cpu_port = 6,
2214         .ops = &gswip_xrx300_switch_ops,
2215 };
2216
2217 static const struct of_device_id gswip_of_match[] = {
2218         { .compatible = "lantiq,xrx200-gswip", .data = &gswip_xrx200 },
2219         { .compatible = "lantiq,xrx300-gswip", .data = &gswip_xrx300 },
2220         { .compatible = "lantiq,xrx330-gswip", .data = &gswip_xrx300 },
2221         {},
2222 };
2223 MODULE_DEVICE_TABLE(of, gswip_of_match);
2224
2225 static struct platform_driver gswip_driver = {
2226         .probe = gswip_probe,
2227         .remove = gswip_remove,
2228         .shutdown = gswip_shutdown,
2229         .driver = {
2230                 .name = "gswip",
2231                 .of_match_table = gswip_of_match,
2232         },
2233 };
2234
2235 module_platform_driver(gswip_driver);
2236
2237 MODULE_FIRMWARE("lantiq/xrx300_phy11g_a21.bin");
2238 MODULE_FIRMWARE("lantiq/xrx300_phy22f_a21.bin");
2239 MODULE_FIRMWARE("lantiq/xrx200_phy11g_a14.bin");
2240 MODULE_FIRMWARE("lantiq/xrx200_phy11g_a22.bin");
2241 MODULE_FIRMWARE("lantiq/xrx200_phy22f_a14.bin");
2242 MODULE_FIRMWARE("lantiq/xrx200_phy22f_a22.bin");
2243 MODULE_AUTHOR("Hauke Mehrtens <hauke@hauke-m.de>");
2244 MODULE_DESCRIPTION("Lantiq / Intel GSWIP driver");
2245 MODULE_LICENSE("GPL v2");