drivers/net/dsa/lan9303-core.c

   1 /*
   2  * Copyright (C) 2017 Pengutronix, Juergen Borleis <kernel@pengutronix.de>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * version 2, as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  */
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/regmap.h>
  18 #include <linux/mutex.h>
  19 #include <linux/mii.h>
  20 #include <linux/phy.h>
  21 #include <linux/if_bridge.h>
  22 #include <linux/etherdevice.h>
  23
  24 #include "lan9303.h"
  25
  26 #define LAN9303_NUM_PORTS 3
  27
  28 /* 13.2 System Control and Status Registers
  29  * Multiply register number by 4 to get address offset.
  30  */
  31 #define LAN9303_CHIP_REV 0x14
  32 # define LAN9303_CHIP_ID 0x9303
  33 #define LAN9303_IRQ_CFG 0x15
  34 # define LAN9303_IRQ_CFG_IRQ_ENABLE BIT(8)
  35 # define LAN9303_IRQ_CFG_IRQ_POL BIT(4)
  36 # define LAN9303_IRQ_CFG_IRQ_TYPE BIT(0)
  37 #define LAN9303_INT_STS 0x16
  38 # define LAN9303_INT_STS_PHY_INT2 BIT(27)
  39 # define LAN9303_INT_STS_PHY_INT1 BIT(26)
  40 #define LAN9303_INT_EN 0x17
  41 # define LAN9303_INT_EN_PHY_INT2_EN BIT(27)
  42 # define LAN9303_INT_EN_PHY_INT1_EN BIT(26)
  43 #define LAN9303_HW_CFG 0x1D
  44 # define LAN9303_HW_CFG_READY BIT(27)
  45 # define LAN9303_HW_CFG_AMDX_EN_PORT2 BIT(26)
  46 # define LAN9303_HW_CFG_AMDX_EN_PORT1 BIT(25)
  47 #define LAN9303_PMI_DATA 0x29
  48 #define LAN9303_PMI_ACCESS 0x2A
  49 # define LAN9303_PMI_ACCESS_PHY_ADDR(x) (((x) & 0x1f) << 11)
  50 # define LAN9303_PMI_ACCESS_MIIRINDA(x) (((x) & 0x1f) << 6)
  51 # define LAN9303_PMI_ACCESS_MII_BUSY BIT(0)
  52 # define LAN9303_PMI_ACCESS_MII_WRITE BIT(1)
  53 #define LAN9303_MANUAL_FC_1 0x68
  54 #define LAN9303_MANUAL_FC_2 0x69
  55 #define LAN9303_MANUAL_FC_0 0x6a
  56 #define LAN9303_SWITCH_CSR_DATA 0x6b
  57 #define LAN9303_SWITCH_CSR_CMD 0x6c
  58 #define LAN9303_SWITCH_CSR_CMD_BUSY BIT(31)
  59 #define LAN9303_SWITCH_CSR_CMD_RW BIT(30)
  60 #define LAN9303_SWITCH_CSR_CMD_LANES (BIT(19) | BIT(18) | BIT(17) | BIT(16))
  61 #define LAN9303_VIRT_PHY_BASE 0x70
  62 #define LAN9303_VIRT_SPECIAL_CTRL 0x77
  63 #define  LAN9303_VIRT_SPECIAL_TURBO BIT(10) /*Turbo MII Enable*/
  64
  65 /*13.4 Switch Fabric Control and Status Registers
  66  * Accessed indirectly via SWITCH_CSR_CMD, SWITCH_CSR_DATA.
  67  */
  68 #define LAN9303_SW_DEV_ID 0x0000
  69 #define LAN9303_SW_RESET 0x0001
  70 #define LAN9303_SW_RESET_RESET BIT(0)
  71 #define LAN9303_SW_IMR 0x0004
  72 #define LAN9303_SW_IPR 0x0005
  73 #define LAN9303_MAC_VER_ID_0 0x0400
  74 #define LAN9303_MAC_RX_CFG_0 0x0401
  75 # define LAN9303_MAC_RX_CFG_X_REJECT_MAC_TYPES BIT(1)
  76 # define LAN9303_MAC_RX_CFG_X_RX_ENABLE BIT(0)
  77 #define LAN9303_MAC_RX_UNDSZE_CNT_0 0x0410
  78 #define LAN9303_MAC_RX_64_CNT_0 0x0411
  79 #define LAN9303_MAC_RX_127_CNT_0 0x0412
  80 #define LAN9303_MAC_RX_255_CNT_0 0x413
  81 #define LAN9303_MAC_RX_511_CNT_0 0x0414
  82 #define LAN9303_MAC_RX_1023_CNT_0 0x0415
  83 #define LAN9303_MAC_RX_MAX_CNT_0 0x0416
  84 #define LAN9303_MAC_RX_OVRSZE_CNT_0 0x0417
  85 #define LAN9303_MAC_RX_PKTOK_CNT_0 0x0418
  86 #define LAN9303_MAC_RX_CRCERR_CNT_0 0x0419
  87 #define LAN9303_MAC_RX_MULCST_CNT_0 0x041a
  88 #define LAN9303_MAC_RX_BRDCST_CNT_0 0x041b
  89 #define LAN9303_MAC_RX_PAUSE_CNT_0 0x041c
  90 #define LAN9303_MAC_RX_FRAG_CNT_0 0x041d
  91 #define LAN9303_MAC_RX_JABB_CNT_0 0x041e
  92 #define LAN9303_MAC_RX_ALIGN_CNT_0 0x041f
  93 #define LAN9303_MAC_RX_PKTLEN_CNT_0 0x0420
  94 #define LAN9303_MAC_RX_GOODPKTLEN_CNT_0 0x0421
  95 #define LAN9303_MAC_RX_SYMBL_CNT_0 0x0422
  96 #define LAN9303_MAC_RX_CTLFRM_CNT_0 0x0423
  97
  98 #define LAN9303_MAC_TX_CFG_0 0x0440
  99 # define LAN9303_MAC_TX_CFG_X_TX_IFG_CONFIG_DEFAULT (21 << 2)
 100 # define LAN9303_MAC_TX_CFG_X_TX_PAD_ENABLE BIT(1)
 101 # define LAN9303_MAC_TX_CFG_X_TX_ENABLE BIT(0)
 102 #define LAN9303_MAC_TX_DEFER_CNT_0 0x0451
 103 #define LAN9303_MAC_TX_PAUSE_CNT_0 0x0452
 104 #define LAN9303_MAC_TX_PKTOK_CNT_0 0x0453
 105 #define LAN9303_MAC_TX_64_CNT_0 0x0454
 106 #define LAN9303_MAC_TX_127_CNT_0 0x0455
 107 #define LAN9303_MAC_TX_255_CNT_0 0x0456
 108 #define LAN9303_MAC_TX_511_CNT_0 0x0457
 109 #define LAN9303_MAC_TX_1023_CNT_0 0x0458
 110 #define LAN9303_MAC_TX_MAX_CNT_0 0x0459
 111 #define LAN9303_MAC_TX_UNDSZE_CNT_0 0x045a
 112 #define LAN9303_MAC_TX_PKTLEN_CNT_0 0x045c
 113 #define LAN9303_MAC_TX_BRDCST_CNT_0 0x045d
 114 #define LAN9303_MAC_TX_MULCST_CNT_0 0x045e
 115 #define LAN9303_MAC_TX_LATECOL_0 0x045f
 116 #define LAN9303_MAC_TX_EXCOL_CNT_0 0x0460
 117 #define LAN9303_MAC_TX_SNGLECOL_CNT_0 0x0461
 118 #define LAN9303_MAC_TX_MULTICOL_CNT_0 0x0462
 119 #define LAN9303_MAC_TX_TOTALCOL_CNT_0 0x0463
 120
 121 #define LAN9303_MAC_VER_ID_1 0x0800
 122 #define LAN9303_MAC_RX_CFG_1 0x0801
 123 #define LAN9303_MAC_TX_CFG_1 0x0840
 124 #define LAN9303_MAC_VER_ID_2 0x0c00
 125 #define LAN9303_MAC_RX_CFG_2 0x0c01
 126 #define LAN9303_MAC_TX_CFG_2 0x0c40
 127 #define LAN9303_SWE_ALR_CMD 0x1800
 128 # define LAN9303_ALR_CMD_MAKE_ENTRY    BIT(2)
 129 # define LAN9303_ALR_CMD_GET_FIRST     BIT(1)
 130 # define LAN9303_ALR_CMD_GET_NEXT      BIT(0)
 131 #define LAN9303_SWE_ALR_WR_DAT_0 0x1801
 132 #define LAN9303_SWE_ALR_WR_DAT_1 0x1802
 133 # define LAN9303_ALR_DAT1_VALID        BIT(26)
 134 # define LAN9303_ALR_DAT1_END_OF_TABL  BIT(25)
 135 # define LAN9303_ALR_DAT1_AGE_OVERRID  BIT(25)
 136 # define LAN9303_ALR_DAT1_STATIC       BIT(24)
 137 # define LAN9303_ALR_DAT1_PORT_BITOFFS  16
 138 # define LAN9303_ALR_DAT1_PORT_MASK    (7 << LAN9303_ALR_DAT1_PORT_BITOFFS)
 139 #define LAN9303_SWE_ALR_RD_DAT_0 0x1805
 140 #define LAN9303_SWE_ALR_RD_DAT_1 0x1806
 141 #define LAN9303_SWE_ALR_CMD_STS 0x1808
 142 # define ALR_STS_MAKE_PEND     BIT(0)
 143 #define LAN9303_SWE_VLAN_CMD 0x180b
 144 # define LAN9303_SWE_VLAN_CMD_RNW BIT(5)
 145 # define LAN9303_SWE_VLAN_CMD_PVIDNVLAN BIT(4)
 146 #define LAN9303_SWE_VLAN_WR_DATA 0x180c
 147 #define LAN9303_SWE_VLAN_RD_DATA 0x180e
 148 # define LAN9303_SWE_VLAN_MEMBER_PORT2 BIT(17)
 149 # define LAN9303_SWE_VLAN_UNTAG_PORT2 BIT(16)
 150 # define LAN9303_SWE_VLAN_MEMBER_PORT1 BIT(15)
 151 # define LAN9303_SWE_VLAN_UNTAG_PORT1 BIT(14)
 152 # define LAN9303_SWE_VLAN_MEMBER_PORT0 BIT(13)
 153 # define LAN9303_SWE_VLAN_UNTAG_PORT0 BIT(12)
 154 #define LAN9303_SWE_VLAN_CMD_STS 0x1810
 155 #define LAN9303_SWE_GLB_INGRESS_CFG 0x1840
 156 # define LAN9303_SWE_GLB_INGR_IGMP_TRAP BIT(7)
 157 # define LAN9303_SWE_GLB_INGR_IGMP_PORT(p) BIT(10 + p)
 158 #define LAN9303_SWE_PORT_STATE 0x1843
 159 # define LAN9303_SWE_PORT_STATE_FORWARDING_PORT2 (0)
 160 # define LAN9303_SWE_PORT_STATE_LEARNING_PORT2 BIT(5)
 161 # define LAN9303_SWE_PORT_STATE_BLOCKING_PORT2 BIT(4)
 162 # define LAN9303_SWE_PORT_STATE_FORWARDING_PORT1 (0)
 163 # define LAN9303_SWE_PORT_STATE_LEARNING_PORT1 BIT(3)
 164 # define LAN9303_SWE_PORT_STATE_BLOCKING_PORT1 BIT(2)
 165 # define LAN9303_SWE_PORT_STATE_FORWARDING_PORT0 (0)
 166 # define LAN9303_SWE_PORT_STATE_LEARNING_PORT0 BIT(1)
 167 # define LAN9303_SWE_PORT_STATE_BLOCKING_PORT0 BIT(0)
 168 # define LAN9303_SWE_PORT_STATE_DISABLED_PORT0 (3)
 169 #define LAN9303_SWE_PORT_MIRROR 0x1846
 170 # define LAN9303_SWE_PORT_MIRROR_SNIFF_ALL BIT(8)
 171 # define LAN9303_SWE_PORT_MIRROR_SNIFFER_PORT2 BIT(7)
 172 # define LAN9303_SWE_PORT_MIRROR_SNIFFER_PORT1 BIT(6)
 173 # define LAN9303_SWE_PORT_MIRROR_SNIFFER_PORT0 BIT(5)
 174 # define LAN9303_SWE_PORT_MIRROR_MIRRORED_PORT2 BIT(4)
 175 # define LAN9303_SWE_PORT_MIRROR_MIRRORED_PORT1 BIT(3)
 176 # define LAN9303_SWE_PORT_MIRROR_MIRRORED_PORT0 BIT(2)
 177 # define LAN9303_SWE_PORT_MIRROR_ENABLE_RX_MIRRORING BIT(1)
 178 # define LAN9303_SWE_PORT_MIRROR_ENABLE_TX_MIRRORING BIT(0)
 179 # define LAN9303_SWE_PORT_MIRROR_DISABLED 0
 180 #define LAN9303_SWE_INGRESS_PORT_TYPE 0x1847
 181 #define  LAN9303_SWE_INGRESS_PORT_TYPE_VLAN 3
 182 #define LAN9303_BM_CFG 0x1c00
 183 #define LAN9303_BM_EGRSS_PORT_TYPE 0x1c0c
 184 # define LAN9303_BM_EGRSS_PORT_TYPE_SPECIAL_TAG_PORT2 (BIT(17) | BIT(16))
 185 # define LAN9303_BM_EGRSS_PORT_TYPE_SPECIAL_TAG_PORT1 (BIT(9) | BIT(8))
 186 # define LAN9303_BM_EGRSS_PORT_TYPE_SPECIAL_TAG_PORT0 (BIT(1) | BIT(0))
 187
 188 #define LAN9303_SWITCH_PORT_REG(port, reg0) (0x400 * (port) + (reg0))
 189
 190 /* the built-in PHYs are of type LAN911X */
 191 #define MII_LAN911X_SPECIAL_MODES 0x12
 192 #define MII_LAN911X_SPECIAL_CONTROL_STATUS 0x1f
 193
 194 static const struct regmap_range lan9303_valid_regs[] = {
 195         regmap_reg_range(0x14, 0x17), /* misc, interrupt */
 196         regmap_reg_range(0x19, 0x19), /* endian test */
 197         regmap_reg_range(0x1d, 0x1d), /* hardware config */
 198         regmap_reg_range(0x23, 0x24), /* general purpose timer */
 199         regmap_reg_range(0x27, 0x27), /* counter */
 200         regmap_reg_range(0x29, 0x2a), /* PMI index regs */
 201         regmap_reg_range(0x68, 0x6a), /* flow control */
 202         regmap_reg_range(0x6b, 0x6c), /* switch fabric indirect regs */
 203         regmap_reg_range(0x6d, 0x6f), /* misc */
 204         regmap_reg_range(0x70, 0x77), /* virtual phy */
 205         regmap_reg_range(0x78, 0x7a), /* GPIO */
 206         regmap_reg_range(0x7c, 0x7e), /* MAC & reset */
 207         regmap_reg_range(0x80, 0xb7), /* switch fabric direct regs (wr only) */
 208 };
 209
 210 static const struct regmap_range lan9303_reserved_ranges[] = {
 211         regmap_reg_range(0x00, 0x13),
 212         regmap_reg_range(0x18, 0x18),
 213         regmap_reg_range(0x1a, 0x1c),
 214         regmap_reg_range(0x1e, 0x22),
 215         regmap_reg_range(0x25, 0x26),
 216         regmap_reg_range(0x28, 0x28),
 217         regmap_reg_range(0x2b, 0x67),
 218         regmap_reg_range(0x7b, 0x7b),
 219         regmap_reg_range(0x7f, 0x7f),
 220         regmap_reg_range(0xb8, 0xff),
 221 };
 222
 223 const struct regmap_access_table lan9303_register_set = {
 224         .yes_ranges = lan9303_valid_regs,
 225         .n_yes_ranges = ARRAY_SIZE(lan9303_valid_regs),
 226         .no_ranges = lan9303_reserved_ranges,
 227         .n_no_ranges = ARRAY_SIZE(lan9303_reserved_ranges),
 228 };
 229 EXPORT_SYMBOL(lan9303_register_set);
 230
 231 static int lan9303_read(struct regmap *regmap, unsigned int offset, u32 *reg)
 232 {
 233         int ret, i;
 234
 235         /* we can lose arbitration for the I2C case, because the device
 236          * tries to detect and read an external EEPROM after reset and acts as
 237          * a master on the shared I2C bus itself. This conflicts with our
 238          * attempts to access the device as a slave at the same moment.
 239          */
 240         for (i = 0; i < 5; i++) {
 241                 ret = regmap_read(regmap, offset, reg);
 242                 if (!ret)
 243                         return 0;
 244                 if (ret != -EAGAIN)
 245                         break;
 246                 msleep(500);
 247         }
 248
 249         return -EIO;
 250 }
 251
 252 static int lan9303_read_wait(struct lan9303 *chip, int offset, u32 mask)
 253 {
 254         int i;
 255
 256         for (i = 0; i < 25; i++) {
 257                 u32 reg;
 258                 int ret;
 259
 260                 ret = lan9303_read(chip->regmap, offset, &reg);
 261                 if (ret) {
 262                         dev_err(chip->dev, "%s failed to read offset %d: %d\n",
 263                                 __func__, offset, ret);
 264                         return ret;
 265                 }
 266                 if (!(reg & mask))
 267                         return 0;
 268                 usleep_range(1000, 2000);
 269         }
 270
 271         return -ETIMEDOUT;
 272 }
 273
 274 static int lan9303_virt_phy_reg_read(struct lan9303 *chip, int regnum)
 275 {
 276         int ret;
 277         u32 val;
 278
 279         if (regnum > MII_EXPANSION)
 280                 return -EINVAL;
 281
 282         ret = lan9303_read(chip->regmap, LAN9303_VIRT_PHY_BASE + regnum, &val);
 283         if (ret)
 284                 return ret;
 285
 286         return val & 0xffff;
 287 }
 288
 289 static int lan9303_virt_phy_reg_write(struct lan9303 *chip, int regnum, u16 val)
 290 {
 291         if (regnum > MII_EXPANSION)
 292                 return -EINVAL;
 293
 294         return regmap_write(chip->regmap, LAN9303_VIRT_PHY_BASE + regnum, val);
 295 }
 296
 297 static int lan9303_indirect_phy_wait_for_completion(struct lan9303 *chip)
 298 {
 299         return lan9303_read_wait(chip, LAN9303_PMI_ACCESS,
 300                                  LAN9303_PMI_ACCESS_MII_BUSY);
 301 }
 302
 303 static int lan9303_indirect_phy_read(struct lan9303 *chip, int addr, int regnum)
 304 {
 305         int ret;
 306         u32 val;
 307
 308         val = LAN9303_PMI_ACCESS_PHY_ADDR(addr);
 309         val |= LAN9303_PMI_ACCESS_MIIRINDA(regnum);
 310
 311         mutex_lock(&chip->indirect_mutex);
 312
 313         ret = lan9303_indirect_phy_wait_for_completion(chip);
 314         if (ret)
 315                 goto on_error;
 316
 317         /* start the MII read cycle */
 318         ret = regmap_write(chip->regmap, LAN9303_PMI_ACCESS, val);
 319         if (ret)
 320                 goto on_error;
 321
 322         ret = lan9303_indirect_phy_wait_for_completion(chip);
 323         if (ret)
 324                 goto on_error;
 325
 326         /* read the result of this operation */
 327         ret = lan9303_read(chip->regmap, LAN9303_PMI_DATA, &val);
 328         if (ret)
 329                 goto on_error;
 330
 331         mutex_unlock(&chip->indirect_mutex);
 332
 333         return val & 0xffff;
 334
 335 on_error:
 336         mutex_unlock(&chip->indirect_mutex);
 337         return ret;
 338 }
 339
 340 static int lan9303_indirect_phy_write(struct lan9303 *chip, int addr,
 341                                       int regnum, u16 val)
 342 {
 343         int ret;
 344         u32 reg;
 345
 346         reg = LAN9303_PMI_ACCESS_PHY_ADDR(addr);
 347         reg |= LAN9303_PMI_ACCESS_MIIRINDA(regnum);
 348         reg |= LAN9303_PMI_ACCESS_MII_WRITE;
 349
 350         mutex_lock(&chip->indirect_mutex);
 351
 352         ret = lan9303_indirect_phy_wait_for_completion(chip);
 353         if (ret)
 354                 goto on_error;
 355
 356         /* write the data first... */
 357         ret = regmap_write(chip->regmap, LAN9303_PMI_DATA, val);
 358         if (ret)
 359                 goto on_error;
 360
 361         /* ...then start the MII write cycle */
 362         ret = regmap_write(chip->regmap, LAN9303_PMI_ACCESS, reg);
 363
 364 on_error:
 365         mutex_unlock(&chip->indirect_mutex);
 366         return ret;
 367 }
 368
 369 const struct lan9303_phy_ops lan9303_indirect_phy_ops = {
 370         .phy_read = lan9303_indirect_phy_read,
 371         .phy_write = lan9303_indirect_phy_write,
 372 };
 373 EXPORT_SYMBOL_GPL(lan9303_indirect_phy_ops);
 374
 375 static int lan9303_switch_wait_for_completion(struct lan9303 *chip)
 376 {
 377         return lan9303_read_wait(chip, LAN9303_SWITCH_CSR_CMD,
 378                                  LAN9303_SWITCH_CSR_CMD_BUSY);
 379 }
 380
 381 static int lan9303_write_switch_reg(struct lan9303 *chip, u16 regnum, u32 val)
 382 {
 383         u32 reg;
 384         int ret;
 385
 386         reg = regnum;
 387         reg |= LAN9303_SWITCH_CSR_CMD_LANES;
 388         reg |= LAN9303_SWITCH_CSR_CMD_BUSY;
 389
 390         mutex_lock(&chip->indirect_mutex);
 391
 392         ret = lan9303_switch_wait_for_completion(chip);
 393         if (ret)
 394                 goto on_error;
 395
 396         ret = regmap_write(chip->regmap, LAN9303_SWITCH_CSR_DATA, val);
 397         if (ret) {
 398                 dev_err(chip->dev, "Failed to write csr data reg: %d\n", ret);
 399                 goto on_error;
 400         }
 401
 402         /* trigger write */
 403         ret = regmap_write(chip->regmap, LAN9303_SWITCH_CSR_CMD, reg);
 404         if (ret)
 405                 dev_err(chip->dev, "Failed to write csr command reg: %d\n",
 406                         ret);
 407
 408 on_error:
 409         mutex_unlock(&chip->indirect_mutex);
 410         return ret;
 411 }
 412
 413 static int lan9303_read_switch_reg(struct lan9303 *chip, u16 regnum, u32 *val)
 414 {
 415         u32 reg;
 416         int ret;
 417
 418         reg = regnum;
 419         reg |= LAN9303_SWITCH_CSR_CMD_LANES;
 420         reg |= LAN9303_SWITCH_CSR_CMD_RW;
 421         reg |= LAN9303_SWITCH_CSR_CMD_BUSY;
 422
 423         mutex_lock(&chip->indirect_mutex);
 424
 425         ret = lan9303_switch_wait_for_completion(chip);
 426         if (ret)
 427                 goto on_error;
 428
 429         /* trigger read */
 430         ret = regmap_write(chip->regmap, LAN9303_SWITCH_CSR_CMD, reg);
 431         if (ret) {
 432                 dev_err(chip->dev, "Failed to write csr command reg: %d\n",
 433                         ret);
 434                 goto on_error;
 435         }
 436
 437         ret = lan9303_switch_wait_for_completion(chip);
 438         if (ret)
 439                 goto on_error;
 440
 441         ret = lan9303_read(chip->regmap, LAN9303_SWITCH_CSR_DATA, val);
 442         if (ret)
 443                 dev_err(chip->dev, "Failed to read csr data reg: %d\n", ret);
 444 on_error:
 445         mutex_unlock(&chip->indirect_mutex);
 446         return ret;
 447 }
 448
 449 static int lan9303_write_switch_reg_mask(struct lan9303 *chip, u16 regnum,
 450                                          u32 val, u32 mask)
 451 {
 452         int ret;
 453         u32 reg;
 454
 455         ret = lan9303_read_switch_reg(chip, regnum, &reg);
 456         if (ret)
 457                 return ret;
 458
 459         reg = (reg & ~mask) | val;
 460
 461         return lan9303_write_switch_reg(chip, regnum, reg);
 462 }
 463
 464 static int lan9303_write_switch_port(struct lan9303 *chip, int port,
 465                                      u16 regnum, u32 val)
 466 {
 467         return lan9303_write_switch_reg(
 468                 chip, LAN9303_SWITCH_PORT_REG(port, regnum), val);
 469 }
 470
 471 static int lan9303_read_switch_port(struct lan9303 *chip, int port,
 472                                     u16 regnum, u32 *val)
 473 {
 474         return lan9303_read_switch_reg(
 475                 chip, LAN9303_SWITCH_PORT_REG(port, regnum), val);
 476 }
 477
 478 static int lan9303_detect_phy_setup(struct lan9303 *chip)
 479 {
 480         int reg;
 481
 482         /* Calculate chip->phy_addr_base:
 483          * Depending on the 'phy_addr_sel_strap' setting, the three phys are
 484          * using IDs 0-1-2 or IDs 1-2-3. We cannot read back the
 485          * 'phy_addr_sel_strap' setting directly, so we need a test, which
 486          * configuration is active:
 487          * Special reg 18 of phy 3 reads as 0x0000, if 'phy_addr_sel_strap' is 0
 488          * and the IDs are 0-1-2, else it contains something different from
 489          * 0x0000, which means 'phy_addr_sel_strap' is 1 and the IDs are 1-2-3.
 490          * 0xffff is returned on MDIO read with no response.
 491          */
 492         reg = chip->ops->phy_read(chip, 3, MII_LAN911X_SPECIAL_MODES);
 493         if (reg < 0) {
 494                 dev_err(chip->dev, "Failed to detect phy config: %d\n", reg);
 495                 return reg;
 496         }
 497
 498         chip->phy_addr_base = reg != 0 && reg != 0xffff;
 499
 500         dev_dbg(chip->dev, "Phy setup '%s' detected\n",
 501                 chip->phy_addr_base ? "1-2-3" : "0-1-2");
 502
 503         return 0;
 504 }
 505
 506 /* Map ALR-port bits to port bitmap, and back */
 507 static const int alrport_2_portmap[] = {1, 2, 4, 0, 3, 5, 6, 7 };
 508 static const int portmap_2_alrport[] = {3, 0, 1, 4, 2, 5, 6, 7 };
 509
 510 /* Return pointer to first free ALR cache entry, return NULL if none */
 511 static struct lan9303_alr_cache_entry *
 512 lan9303_alr_cache_find_free(struct lan9303 *chip)
 513 {
 514         int i;
 515         struct lan9303_alr_cache_entry *entr = chip->alr_cache;
 516
 517         for (i = 0; i < LAN9303_NUM_ALR_RECORDS; i++, entr++)
 518                 if (entr->port_map == 0)
 519                         return entr;
 520
 521         return NULL;
 522 }
 523
 524 /* Return pointer to ALR cache entry matching MAC address */
 525 static struct lan9303_alr_cache_entry *
 526 lan9303_alr_cache_find_mac(struct lan9303 *chip, const u8 *mac_addr)
 527 {
 528         int i;
 529         struct lan9303_alr_cache_entry *entr = chip->alr_cache;
 530
 531         BUILD_BUG_ON_MSG(sizeof(struct lan9303_alr_cache_entry) & 1,
 532                          "ether_addr_equal require u16 alignment");
 533
 534         for (i = 0; i < LAN9303_NUM_ALR_RECORDS; i++, entr++)
 535                 if (ether_addr_equal(entr->mac_addr, mac_addr))
 536                         return entr;
 537
 538         return NULL;
 539 }
 540
 541 static int lan9303_csr_reg_wait(struct lan9303 *chip, int regno, u32 mask)
 542 {
 543         int i;
 544
 545         for (i = 0; i < 25; i++) {
 546                 u32 reg;
 547
 548                 lan9303_read_switch_reg(chip, regno, &reg);
 549                 if (!(reg & mask))
 550                         return 0;
 551                 usleep_range(1000, 2000);
 552         }
 553
 554         return -ETIMEDOUT;
 555 }
 556
 557 static int lan9303_alr_make_entry_raw(struct lan9303 *chip, u32 dat0, u32 dat1)
 558 {
 559         lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_WR_DAT_0, dat0);
 560         lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_WR_DAT_1, dat1);
 561         lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_CMD,
 562                                  LAN9303_ALR_CMD_MAKE_ENTRY);
 563         lan9303_csr_reg_wait(chip, LAN9303_SWE_ALR_CMD_STS, ALR_STS_MAKE_PEND);
 564         lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_CMD, 0);
 565
 566         return 0;
 567 }
 568
 569 typedef int alr_loop_cb_t(struct lan9303 *chip, u32 dat0, u32 dat1,
 570                           int portmap, void *ctx);
 571
 572 static int lan9303_alr_loop(struct lan9303 *chip, alr_loop_cb_t *cb, void *ctx)
 573 {
 574         int ret = 0, i;
 575
 576         mutex_lock(&chip->alr_mutex);
 577         lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_CMD,
 578                                  LAN9303_ALR_CMD_GET_FIRST);
 579         lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_CMD, 0);
 580
 581         for (i = 1; i < LAN9303_NUM_ALR_RECORDS; i++) {
 582                 u32 dat0, dat1;
 583                 int alrport, portmap;
 584
 585                 lan9303_read_switch_reg(chip, LAN9303_SWE_ALR_RD_DAT_0, &dat0);
 586                 lan9303_read_switch_reg(chip, LAN9303_SWE_ALR_RD_DAT_1, &dat1);
 587                 if (dat1 & LAN9303_ALR_DAT1_END_OF_TABL)
 588                         break;
 589
 590                 alrport = (dat1 & LAN9303_ALR_DAT1_PORT_MASK) >>
 591                                                 LAN9303_ALR_DAT1_PORT_BITOFFS;
 592                 portmap = alrport_2_portmap[alrport];
 593
 594                 ret = cb(chip, dat0, dat1, portmap, ctx);
 595                 if (ret)
 596                         break;
 597
 598                 lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_CMD,
 599                                          LAN9303_ALR_CMD_GET_NEXT);
 600                 lan9303_write_switch_reg(chip, LAN9303_SWE_ALR_CMD, 0);
 601         }
 602         mutex_unlock(&chip->alr_mutex);
 603
 604         return ret;
 605 }
 606
 607 static void alr_reg_to_mac(u32 dat0, u32 dat1, u8 mac[6])
 608 {
 609         mac[0] = (dat0 >>  0) & 0xff;
 610         mac[1] = (dat0 >>  8) & 0xff;
 611         mac[2] = (dat0 >> 16) & 0xff;
 612         mac[3] = (dat0 >> 24) & 0xff;
 613         mac[4] = (dat1 >>  0) & 0xff;
 614         mac[5] = (dat1 >>  8) & 0xff;
 615 }
 616
 617 struct del_port_learned_ctx {
 618         int port;
 619 };
 620
 621 /* Clear learned (non-static) entry on given port */
 622 static int alr_loop_cb_del_port_learned(struct lan9303 *chip, u32 dat0,
 623                                         u32 dat1, int portmap, void *ctx)
 624 {
 625         struct del_port_learned_ctx *del_ctx = ctx;
 626         int port = del_ctx->port;
 627
 628         if (((BIT(port) & portmap) == 0) || (dat1 & LAN9303_ALR_DAT1_STATIC))
 629                 return 0;
 630
 631         /* learned entries has only one port, we can just delete */
 632         dat1 &= ~LAN9303_ALR_DAT1_VALID; /* delete entry */
 633         lan9303_alr_make_entry_raw(chip, dat0, dat1);
 634
 635         return 0;
 636 }
 637
 638 struct port_fdb_dump_ctx {
 639         int port;
 640         void *data;
 641         dsa_fdb_dump_cb_t *cb;
 642 };
 643
 644 static int alr_loop_cb_fdb_port_dump(struct lan9303 *chip, u32 dat0,
 645                                      u32 dat1, int portmap, void *ctx)
 646 {
 647         struct port_fdb_dump_ctx *dump_ctx = ctx;
 648         u8 mac[ETH_ALEN];
 649         bool is_static;
 650
 651         if ((BIT(dump_ctx->port) & portmap) == 0)
 652                 return 0;
 653
 654         alr_reg_to_mac(dat0, dat1, mac);
 655         is_static = !!(dat1 & LAN9303_ALR_DAT1_STATIC);
 656         return dump_ctx->cb(mac, 0, is_static, dump_ctx->data);
 657 }
 658
 659 /* Set a static ALR entry. Delete entry if port_map is zero */
 660 static void lan9303_alr_set_entry(struct lan9303 *chip, const u8 *mac,
 661                                   u8 port_map, bool stp_override)
 662 {
 663         u32 dat0, dat1, alr_port;
 664
 665         dev_dbg(chip->dev, "%s(%pM, %d)\n", __func__, mac, port_map);
 666         dat1 = LAN9303_ALR_DAT1_STATIC;
 667         if (port_map)
 668                 dat1 |= LAN9303_ALR_DAT1_VALID;
 669         /* otherwise no ports: delete entry */
 670         if (stp_override)
 671                 dat1 |= LAN9303_ALR_DAT1_AGE_OVERRID;
 672
 673         alr_port = portmap_2_alrport[port_map & 7];
 674         dat1 &= ~LAN9303_ALR_DAT1_PORT_MASK;
 675         dat1 |= alr_port << LAN9303_ALR_DAT1_PORT_BITOFFS;
 676
 677         dat0 = 0;
 678         dat0 |= (mac[0] << 0);
 679         dat0 |= (mac[1] << 8);
 680         dat0 |= (mac[2] << 16);
 681         dat0 |= (mac[3] << 24);
 682
 683         dat1 |= (mac[4] << 0);
 684         dat1 |= (mac[5] << 8);
 685
 686         lan9303_alr_make_entry_raw(chip, dat0, dat1);
 687 }
 688
 689 /* Add port to static ALR entry, create new static entry if needed */
 690 static int lan9303_alr_add_port(struct lan9303 *chip, const u8 *mac, int port,
 691                                 bool stp_override)
 692 {
 693         struct lan9303_alr_cache_entry *entr;
 694
 695         mutex_lock(&chip->alr_mutex);
 696         entr = lan9303_alr_cache_find_mac(chip, mac);
 697         if (!entr) { /*New entry */
 698                 entr = lan9303_alr_cache_find_free(chip);
 699                 if (!entr) {
 700                         mutex_unlock(&chip->alr_mutex);
 701                         return -ENOSPC;
 702                 }
 703                 ether_addr_copy(entr->mac_addr, mac);
 704         }
 705         entr->port_map |= BIT(port);
 706         entr->stp_override = stp_override;
 707         lan9303_alr_set_entry(chip, mac, entr->port_map, stp_override);
 708         mutex_unlock(&chip->alr_mutex);
 709
 710         return 0;
 711 }
 712
 713 /* Delete static port from ALR entry, delete entry if last port */
 714 static int lan9303_alr_del_port(struct lan9303 *chip, const u8 *mac, int port)
 715 {
 716         struct lan9303_alr_cache_entry *entr;
 717
 718         mutex_lock(&chip->alr_mutex);
 719         entr = lan9303_alr_cache_find_mac(chip, mac);
 720         if (!entr)
 721                 goto out;  /* no static entry found */
 722
 723         entr->port_map &= ~BIT(port);
 724         if (entr->port_map == 0) /* zero means its free again */
 725                 eth_zero_addr(entr->mac_addr);
 726         lan9303_alr_set_entry(chip, mac, entr->port_map, entr->stp_override);
 727
 728 out:
 729         mutex_unlock(&chip->alr_mutex);
 730         return 0;
 731 }
 732
 733 static int lan9303_disable_processing_port(struct lan9303 *chip,
 734                                            unsigned int port)
 735 {
 736         int ret;
 737
 738         /* disable RX, but keep register reset default values else */
 739         ret = lan9303_write_switch_port(chip, port, LAN9303_MAC_RX_CFG_0,
 740                                         LAN9303_MAC_RX_CFG_X_REJECT_MAC_TYPES);
 741         if (ret)
 742                 return ret;
 743
 744         /* disable TX, but keep register reset default values else */
 745         return lan9303_write_switch_port(chip, port, LAN9303_MAC_TX_CFG_0,
 746                                 LAN9303_MAC_TX_CFG_X_TX_IFG_CONFIG_DEFAULT |
 747                                 LAN9303_MAC_TX_CFG_X_TX_PAD_ENABLE);
 748 }
 749
 750 static int lan9303_enable_processing_port(struct lan9303 *chip,
 751                                           unsigned int port)
 752 {
 753         int ret;
 754
 755         /* enable RX and keep register reset default values else */
 756         ret = lan9303_write_switch_port(chip, port, LAN9303_MAC_RX_CFG_0,
 757                                         LAN9303_MAC_RX_CFG_X_REJECT_MAC_TYPES |
 758                                         LAN9303_MAC_RX_CFG_X_RX_ENABLE);
 759         if (ret)
 760                 return ret;
 761
 762         /* enable TX and keep register reset default values else */
 763         return lan9303_write_switch_port(chip, port, LAN9303_MAC_TX_CFG_0,
 764                                 LAN9303_MAC_TX_CFG_X_TX_IFG_CONFIG_DEFAULT |
 765                                 LAN9303_MAC_TX_CFG_X_TX_PAD_ENABLE |
 766                                 LAN9303_MAC_TX_CFG_X_TX_ENABLE);
 767 }
 768
 769 /* forward special tagged packets from port 0 to port 1 *or* port 2 */
 770 static int lan9303_setup_tagging(struct lan9303 *chip)
 771 {
 772         int ret;
 773         u32 val;
 774         /* enable defining the destination port via special VLAN tagging
 775          * for port 0
 776          */
 777         ret = lan9303_write_switch_reg(chip, LAN9303_SWE_INGRESS_PORT_TYPE,
 778                                        LAN9303_SWE_INGRESS_PORT_TYPE_VLAN);
 779         if (ret)
 780                 return ret;
 781
 782         /* tag incoming packets at port 1 and 2 on their way to port 0 to be
 783          * able to discover their source port
 784          */
 785         val = LAN9303_BM_EGRSS_PORT_TYPE_SPECIAL_TAG_PORT0;
 786         return lan9303_write_switch_reg(chip, LAN9303_BM_EGRSS_PORT_TYPE, val);
 787 }
 788
 789 /* We want a special working switch:
 790  * - do not forward packets between port 1 and 2
 791  * - forward everything from port 1 to port 0
 792  * - forward everything from port 2 to port 0
 793  */
 794 static int lan9303_separate_ports(struct lan9303 *chip)
 795 {
 796         int ret;
 797
 798         lan9303_alr_del_port(chip, eth_stp_addr, 0);
 799         ret = lan9303_write_switch_reg(chip, LAN9303_SWE_PORT_MIRROR,
 800                                 LAN9303_SWE_PORT_MIRROR_SNIFFER_PORT0 |
 801                                 LAN9303_SWE_PORT_MIRROR_MIRRORED_PORT1 |
 802                                 LAN9303_SWE_PORT_MIRROR_MIRRORED_PORT2 |
 803                                 LAN9303_SWE_PORT_MIRROR_ENABLE_RX_MIRRORING |
 804                                 LAN9303_SWE_PORT_MIRROR_SNIFF_ALL);
 805         if (ret)
 806                 return ret;
 807
 808         /* prevent port 1 and 2 from forwarding packets by their own */
 809         return lan9303_write_switch_reg(chip, LAN9303_SWE_PORT_STATE,
 810                                 LAN9303_SWE_PORT_STATE_FORWARDING_PORT0 |
 811                                 LAN9303_SWE_PORT_STATE_BLOCKING_PORT1 |
 812                                 LAN9303_SWE_PORT_STATE_BLOCKING_PORT2);
 813 }
 814
 815 static void lan9303_bridge_ports(struct lan9303 *chip)
 816 {
 817         /* ports bridged: remove mirroring */
 818         lan9303_write_switch_reg(chip, LAN9303_SWE_PORT_MIRROR,
 819                                  LAN9303_SWE_PORT_MIRROR_DISABLED);
 820
 821         lan9303_write_switch_reg(chip, LAN9303_SWE_PORT_STATE,
 822                                  chip->swe_port_state);
 823         lan9303_alr_add_port(chip, eth_stp_addr, 0, true);
 824 }
 825
 826 static void lan9303_handle_reset(struct lan9303 *chip)
 827 {
 828         if (!chip->reset_gpio)
 829                 return;
 830
 831         if (chip->reset_duration != 0)
 832                 msleep(chip->reset_duration);
 833
 834         /* release (deassert) reset and activate the device */
 835         gpiod_set_value_cansleep(chip->reset_gpio, 0);
 836 }
 837
 838 /* stop processing packets for all ports */
 839 static int lan9303_disable_processing(struct lan9303 *chip)
 840 {
 841         int p;
 842
 843         for (p = 1; p < LAN9303_NUM_PORTS; p++) {
 844                 int ret = lan9303_disable_processing_port(chip, p);
 845
 846                 if (ret)
 847                         return ret;
 848         }
 849
 850         return 0;
 851 }
 852
 853 static int lan9303_check_device(struct lan9303 *chip)
 854 {
 855         int ret;
 856         u32 reg;
 857
 858         ret = lan9303_read(chip->regmap, LAN9303_CHIP_REV, &reg);
 859         if (ret) {
 860                 dev_err(chip->dev, "failed to read chip revision register: %d\n",
 861                         ret);
 862                 if (!chip->reset_gpio) {
 863                         dev_dbg(chip->dev,
 864                                 "hint: maybe failed due to missing reset GPIO\n");
 865                 }
 866                 return ret;
 867         }
 868
 869         if ((reg >> 16) != LAN9303_CHIP_ID) {
 870                 dev_err(chip->dev, "expecting LAN9303 chip, but found: %X\n",
 871                         reg >> 16);
 872                 return -ENODEV;
 873         }
 874
 875         /* The default state of the LAN9303 device is to forward packets between
 876          * all ports (if not configured differently by an external EEPROM).
 877          * The initial state of a DSA device must be forwarding packets only
 878          * between the external and the internal ports and no forwarding
 879          * between the external ports. In preparation we stop packet handling
 880          * at all for now until the LAN9303 device is re-programmed accordingly.
 881          */
 882         ret = lan9303_disable_processing(chip);
 883         if (ret)
 884                 dev_warn(chip->dev, "failed to disable switching %d\n", ret);
 885
 886         dev_info(chip->dev, "Found LAN9303 rev. %u\n", reg & 0xffff);
 887
 888         ret = lan9303_detect_phy_setup(chip);
 889         if (ret) {
 890                 dev_err(chip->dev,
 891                         "failed to discover phy bootstrap setup: %d\n", ret);
 892                 return ret;
 893         }
 894
 895         return 0;
 896 }
 897
 898 /* ---------------------------- DSA -----------------------------------*/
 899
 900 static enum dsa_tag_protocol lan9303_get_tag_protocol(struct dsa_switch *ds,
 901                                                       int port)
 902 {
 903         return DSA_TAG_PROTO_LAN9303;
 904 }
 905
 906 static int lan9303_setup(struct dsa_switch *ds)
 907 {
 908         struct lan9303 *chip = ds->priv;
 909         int ret;
 910
 911         /* Make sure that port 0 is the cpu port */
 912         if (!dsa_is_cpu_port(ds, 0)) {
 913                 dev_err(chip->dev, "port 0 is not the CPU port\n");
 914                 return -EINVAL;
 915         }
 916
 917         ret = lan9303_setup_tagging(chip);
 918         if (ret)
 919                 dev_err(chip->dev, "failed to setup port tagging %d\n", ret);
 920
 921         ret = lan9303_separate_ports(chip);
 922         if (ret)
 923                 dev_err(chip->dev, "failed to separate ports %d\n", ret);
 924
 925         ret = lan9303_enable_processing_port(chip, 0);
 926         if (ret)
 927                 dev_err(chip->dev, "failed to re-enable switching %d\n", ret);
 928
 929         /* Trap IGMP to port 0 */
 930         ret = lan9303_write_switch_reg_mask(chip, LAN9303_SWE_GLB_INGRESS_CFG,
 931                                             LAN9303_SWE_GLB_INGR_IGMP_TRAP |
 932                                             LAN9303_SWE_GLB_INGR_IGMP_PORT(0),
 933                                             LAN9303_SWE_GLB_INGR_IGMP_PORT(1) |
 934                                             LAN9303_SWE_GLB_INGR_IGMP_PORT(2));
 935         if (ret)
 936                 dev_err(chip->dev, "failed to setup IGMP trap %d\n", ret);
 937
 938         return 0;
 939 }
 940
 941 struct lan9303_mib_desc {
 942         unsigned int offset; /* offset of first MAC */
 943         const char *name;
 944 };
 945
 946 static const struct lan9303_mib_desc lan9303_mib[] = {
 947         { .offset = LAN9303_MAC_RX_BRDCST_CNT_0, .name = "RxBroad", },
 948         { .offset = LAN9303_MAC_RX_PAUSE_CNT_0, .name = "RxPause", },
 949         { .offset = LAN9303_MAC_RX_MULCST_CNT_0, .name = "RxMulti", },
 950         { .offset = LAN9303_MAC_RX_PKTOK_CNT_0, .name = "RxOk", },
 951         { .offset = LAN9303_MAC_RX_CRCERR_CNT_0, .name = "RxCrcErr", },
 952         { .offset = LAN9303_MAC_RX_ALIGN_CNT_0, .name = "RxAlignErr", },
 953         { .offset = LAN9303_MAC_RX_JABB_CNT_0, .name = "RxJabber", },
 954         { .offset = LAN9303_MAC_RX_FRAG_CNT_0, .name = "RxFragment", },
 955         { .offset = LAN9303_MAC_RX_64_CNT_0, .name = "Rx64Byte", },
 956         { .offset = LAN9303_MAC_RX_127_CNT_0, .name = "Rx128Byte", },
 957         { .offset = LAN9303_MAC_RX_255_CNT_0, .name = "Rx256Byte", },
 958         { .offset = LAN9303_MAC_RX_511_CNT_0, .name = "Rx512Byte", },
 959         { .offset = LAN9303_MAC_RX_1023_CNT_0, .name = "Rx1024Byte", },
 960         { .offset = LAN9303_MAC_RX_MAX_CNT_0, .name = "RxMaxByte", },
 961         { .offset = LAN9303_MAC_RX_PKTLEN_CNT_0, .name = "RxByteCnt", },
 962         { .offset = LAN9303_MAC_RX_SYMBL_CNT_0, .name = "RxSymbolCnt", },
 963         { .offset = LAN9303_MAC_RX_CTLFRM_CNT_0, .name = "RxCfs", },
 964         { .offset = LAN9303_MAC_RX_OVRSZE_CNT_0, .name = "RxOverFlow", },
 965         { .offset = LAN9303_MAC_TX_UNDSZE_CNT_0, .name = "TxShort", },
 966         { .offset = LAN9303_MAC_TX_BRDCST_CNT_0, .name = "TxBroad", },
 967         { .offset = LAN9303_MAC_TX_PAUSE_CNT_0, .name = "TxPause", },
 968         { .offset = LAN9303_MAC_TX_MULCST_CNT_0, .name = "TxMulti", },
 969         { .offset = LAN9303_MAC_RX_UNDSZE_CNT_0, .name = "RxShort", },
 970         { .offset = LAN9303_MAC_TX_64_CNT_0, .name = "Tx64Byte", },
 971         { .offset = LAN9303_MAC_TX_127_CNT_0, .name = "Tx128Byte", },
 972         { .offset = LAN9303_MAC_TX_255_CNT_0, .name = "Tx256Byte", },
 973         { .offset = LAN9303_MAC_TX_511_CNT_0, .name = "Tx512Byte", },
 974         { .offset = LAN9303_MAC_TX_1023_CNT_0, .name = "Tx1024Byte", },
 975         { .offset = LAN9303_MAC_TX_MAX_CNT_0, .name = "TxMaxByte", },
 976         { .offset = LAN9303_MAC_TX_PKTLEN_CNT_0, .name = "TxByteCnt", },
 977         { .offset = LAN9303_MAC_TX_PKTOK_CNT_0, .name = "TxOk", },
 978         { .offset = LAN9303_MAC_TX_TOTALCOL_CNT_0, .name = "TxCollision", },
 979         { .offset = LAN9303_MAC_TX_MULTICOL_CNT_0, .name = "TxMultiCol", },
 980         { .offset = LAN9303_MAC_TX_SNGLECOL_CNT_0, .name = "TxSingleCol", },
 981         { .offset = LAN9303_MAC_TX_EXCOL_CNT_0, .name = "TxExcCol", },
 982         { .offset = LAN9303_MAC_TX_DEFER_CNT_0, .name = "TxDefer", },
 983         { .offset = LAN9303_MAC_TX_LATECOL_0, .name = "TxLateCol", },
 984 };
 985
 986 static void lan9303_get_strings(struct dsa_switch *ds, int port,
 987                                 u32 stringset, uint8_t *data)
 988 {
 989         unsigned int u;
 990
 991         if (stringset != ETH_SS_STATS)
 992                 return;
 993
 994         for (u = 0; u < ARRAY_SIZE(lan9303_mib); u++) {
 995                 strncpy(data + u * ETH_GSTRING_LEN, lan9303_mib[u].name,
 996                         ETH_GSTRING_LEN);
 997         }
 998 }
 999
1000 static void lan9303_get_ethtool_stats(struct dsa_switch *ds, int port,
1001                                       uint64_t *data)
1002 {
1003         struct lan9303 *chip = ds->priv;
1004         unsigned int u;
1005
1006         for (u = 0; u < ARRAY_SIZE(lan9303_mib); u++) {
1007                 u32 reg;
1008                 int ret;
1009
1010                 ret = lan9303_read_switch_port(
1011                         chip, port, lan9303_mib[u].offset, &reg);
1012
1013                 if (ret)
1014                         dev_warn(chip->dev, "Reading status port %d reg %u failed\n",
1015                                  port, lan9303_mib[u].offset);
1016                 data[u] = reg;
1017         }
1018 }
1019
1020 static int lan9303_get_sset_count(struct dsa_switch *ds, int port, int sset)
1021 {
1022         if (sset != ETH_SS_STATS)
1023                 return 0;
1024
1025         return ARRAY_SIZE(lan9303_mib);
1026 }
1027
1028 static int lan9303_phy_read(struct dsa_switch *ds, int phy, int regnum)
1029 {
1030         struct lan9303 *chip = ds->priv;
1031         int phy_base = chip->phy_addr_base;
1032
1033         if (phy == phy_base)
1034                 return lan9303_virt_phy_reg_read(chip, regnum);
1035         if (phy > phy_base + 2)
1036                 return -ENODEV;
1037
1038         return chip->ops->phy_read(chip, phy, regnum);
1039 }
1040
1041 static int lan9303_phy_write(struct dsa_switch *ds, int phy, int regnum,
1042                              u16 val)
1043 {
1044         struct lan9303 *chip = ds->priv;
1045         int phy_base = chip->phy_addr_base;
1046
1047         if (phy == phy_base)
1048                 return lan9303_virt_phy_reg_write(chip, regnum, val);
1049         if (phy > phy_base + 2)
1050                 return -ENODEV;
1051
1052         return chip->ops->phy_write(chip, phy, regnum, val);
1053 }
1054
1055 static void lan9303_adjust_link(struct dsa_switch *ds, int port,
1056                                 struct phy_device *phydev)
1057 {
1058         struct lan9303 *chip = ds->priv;
1059         int ctl, res;
1060
1061         if (!phy_is_pseudo_fixed_link(phydev))
1062                 return;
1063
1064         ctl = lan9303_phy_read(ds, port, MII_BMCR);
1065
1066         ctl &= ~BMCR_ANENABLE;
1067
1068         if (phydev->speed == SPEED_100)
1069                 ctl |= BMCR_SPEED100;
1070         else if (phydev->speed == SPEED_10)
1071                 ctl &= ~BMCR_SPEED100;
1072         else
1073                 dev_err(ds->dev, "unsupported speed: %d\n", phydev->speed);
1074
1075         if (phydev->duplex == DUPLEX_FULL)
1076                 ctl |= BMCR_FULLDPLX;
1077         else
1078                 ctl &= ~BMCR_FULLDPLX;
1079
1080         res =  lan9303_phy_write(ds, port, MII_BMCR, ctl);
1081
1082         if (port == chip->phy_addr_base) {
1083                 /* Virtual Phy: Remove Turbo 200Mbit mode */
1084                 lan9303_read(chip->regmap, LAN9303_VIRT_SPECIAL_CTRL, &ctl);
1085
1086                 ctl &= ~LAN9303_VIRT_SPECIAL_TURBO;
1087                 res =  regmap_write(chip->regmap,
1088                                     LAN9303_VIRT_SPECIAL_CTRL, ctl);
1089         }
1090 }
1091
1092 static int lan9303_port_enable(struct dsa_switch *ds, int port,
1093                                struct phy_device *phy)
1094 {
1095         struct lan9303 *chip = ds->priv;
1096
1097         return lan9303_enable_processing_port(chip, port);
1098 }
1099
1100 static void lan9303_port_disable(struct dsa_switch *ds, int port,
1101                                  struct phy_device *phy)
1102 {
1103         struct lan9303 *chip = ds->priv;
1104
1105         lan9303_disable_processing_port(chip, port);
1106         lan9303_phy_write(ds, chip->phy_addr_base + port, MII_BMCR, BMCR_PDOWN);
1107 }
1108
1109 static int lan9303_port_bridge_join(struct dsa_switch *ds, int port,
1110                                     struct net_device *br)
1111 {
1112         struct lan9303 *chip = ds->priv;
1113
1114         dev_dbg(chip->dev, "%s(port %d)\n", __func__, port);
1115         if (dsa_to_port(ds, 1)->bridge_dev == dsa_to_port(ds, 2)->bridge_dev) {
1116                 lan9303_bridge_ports(chip);
1117                 chip->is_bridged = true;  /* unleash stp_state_set() */
1118         }
1119
1120         return 0;
1121 }
1122
1123 static void lan9303_port_bridge_leave(struct dsa_switch *ds, int port,
1124                                       struct net_device *br)
1125 {
1126         struct lan9303 *chip = ds->priv;
1127
1128         dev_dbg(chip->dev, "%s(port %d)\n", __func__, port);
1129         if (chip->is_bridged) {
1130                 lan9303_separate_ports(chip);
1131                 chip->is_bridged = false;
1132         }
1133 }
1134
1135 static void lan9303_port_stp_state_set(struct dsa_switch *ds, int port,
1136                                        u8 state)
1137 {
1138         int portmask, portstate;
1139         struct lan9303 *chip = ds->priv;
1140
1141         dev_dbg(chip->dev, "%s(port %d, state %d)\n",
1142                 __func__, port, state);
1143
1144         switch (state) {
1145         case BR_STATE_DISABLED:
1146                 portstate = LAN9303_SWE_PORT_STATE_DISABLED_PORT0;
1147                 break;
1148         case BR_STATE_BLOCKING:
1149         case BR_STATE_LISTENING:
1150                 portstate = LAN9303_SWE_PORT_STATE_BLOCKING_PORT0;
1151                 break;
1152         case BR_STATE_LEARNING:
1153                 portstate = LAN9303_SWE_PORT_STATE_LEARNING_PORT0;
1154                 break;
1155         case BR_STATE_FORWARDING:
1156                 portstate = LAN9303_SWE_PORT_STATE_FORWARDING_PORT0;
1157                 break;
1158         default:
1159                 portstate = LAN9303_SWE_PORT_STATE_DISABLED_PORT0;
1160                 dev_err(chip->dev, "unknown stp state: port %d, state %d\n",
1161                         port, state);
1162         }
1163
1164         portmask = 0x3 << (port * 2);
1165         portstate <<= (port * 2);
1166
1167         chip->swe_port_state = (chip->swe_port_state & ~portmask) | portstate;
1168
1169         if (chip->is_bridged)
1170                 lan9303_write_switch_reg(chip, LAN9303_SWE_PORT_STATE,
1171                                          chip->swe_port_state);
1172         /* else: touching SWE_PORT_STATE would break port separation */
1173 }
1174
1175 static void lan9303_port_fast_age(struct dsa_switch *ds, int port)
1176 {
1177         struct lan9303 *chip = ds->priv;
1178         struct del_port_learned_ctx del_ctx = {
1179                 .port = port,
1180         };
1181
1182         dev_dbg(chip->dev, "%s(%d)\n", __func__, port);
1183         lan9303_alr_loop(chip, alr_loop_cb_del_port_learned, &del_ctx);
1184 }
1185
1186 static int lan9303_port_fdb_add(struct dsa_switch *ds, int port,
1187                                 const unsigned char *addr, u16 vid)
1188 {
1189         struct lan9303 *chip = ds->priv;
1190
1191         dev_dbg(chip->dev, "%s(%d, %pM, %d)\n", __func__, port, addr, vid);
1192         if (vid)
1193                 return -EOPNOTSUPP;
1194
1195         return lan9303_alr_add_port(chip, addr, port, false);
1196 }
1197
1198 static int lan9303_port_fdb_del(struct dsa_switch *ds, int port,
1199                                 const unsigned char *addr, u16 vid)
1200
1201 {
1202         struct lan9303 *chip = ds->priv;
1203
1204         dev_dbg(chip->dev, "%s(%d, %pM, %d)\n", __func__, port, addr, vid);
1205         if (vid)
1206                 return -EOPNOTSUPP;
1207         lan9303_alr_del_port(chip, addr, port);
1208
1209         return 0;
1210 }
1211
1212 static int lan9303_port_fdb_dump(struct dsa_switch *ds, int port,
1213                                  dsa_fdb_dump_cb_t *cb, void *data)
1214 {
1215         struct lan9303 *chip = ds->priv;
1216         struct port_fdb_dump_ctx dump_ctx = {
1217                 .port = port,
1218                 .data = data,
1219                 .cb   = cb,
1220         };
1221
1222         dev_dbg(chip->dev, "%s(%d)\n", __func__, port);
1223         return lan9303_alr_loop(chip, alr_loop_cb_fdb_port_dump, &dump_ctx);
1224 }
1225
1226 static int lan9303_port_mdb_prepare(struct dsa_switch *ds, int port,
1227                                     const struct switchdev_obj_port_mdb *mdb)
1228 {
1229         struct lan9303 *chip = ds->priv;
1230
1231         dev_dbg(chip->dev, "%s(%d, %pM, %d)\n", __func__, port, mdb->addr,
1232                 mdb->vid);
1233         if (mdb->vid)
1234                 return -EOPNOTSUPP;
1235         if (lan9303_alr_cache_find_mac(chip, mdb->addr))
1236                 return 0;
1237         if (!lan9303_alr_cache_find_free(chip))
1238                 return -ENOSPC;
1239
1240         return 0;
1241 }
1242
1243 static void lan9303_port_mdb_add(struct dsa_switch *ds, int port,
1244                                  const struct switchdev_obj_port_mdb *mdb)
1245 {
1246         struct lan9303 *chip = ds->priv;
1247
1248         dev_dbg(chip->dev, "%s(%d, %pM, %d)\n", __func__, port, mdb->addr,
1249                 mdb->vid);
1250         lan9303_alr_add_port(chip, mdb->addr, port, false);
1251 }
1252
1253 static int lan9303_port_mdb_del(struct dsa_switch *ds, int port,
1254                                 const struct switchdev_obj_port_mdb *mdb)
1255 {
1256         struct lan9303 *chip = ds->priv;
1257
1258         dev_dbg(chip->dev, "%s(%d, %pM, %d)\n", __func__, port, mdb->addr,
1259                 mdb->vid);
1260         if (mdb->vid)
1261                 return -EOPNOTSUPP;
1262         lan9303_alr_del_port(chip, mdb->addr, port);
1263
1264         return 0;
1265 }
1266
1267 static const struct dsa_switch_ops lan9303_switch_ops = {
1268         .get_tag_protocol = lan9303_get_tag_protocol,
1269         .setup = lan9303_setup,
1270         .get_strings = lan9303_get_strings,
1271         .phy_read = lan9303_phy_read,
1272         .phy_write = lan9303_phy_write,
1273         .adjust_link = lan9303_adjust_link,
1274         .get_ethtool_stats = lan9303_get_ethtool_stats,
1275         .get_sset_count = lan9303_get_sset_count,
1276         .port_enable = lan9303_port_enable,
1277         .port_disable = lan9303_port_disable,
1278         .port_bridge_join       = lan9303_port_bridge_join,
1279         .port_bridge_leave      = lan9303_port_bridge_leave,
1280         .port_stp_state_set     = lan9303_port_stp_state_set,
1281         .port_fast_age          = lan9303_port_fast_age,
1282         .port_fdb_add           = lan9303_port_fdb_add,
1283         .port_fdb_del           = lan9303_port_fdb_del,
1284         .port_fdb_dump          = lan9303_port_fdb_dump,
1285         .port_mdb_prepare       = lan9303_port_mdb_prepare,
1286         .port_mdb_add           = lan9303_port_mdb_add,
1287         .port_mdb_del           = lan9303_port_mdb_del,
1288 };
1289
1290 static int lan9303_register_switch(struct lan9303 *chip)
1291 {
1292         int base;
1293
1294         chip->ds = dsa_switch_alloc(chip->dev, LAN9303_NUM_PORTS);
1295         if (!chip->ds)
1296                 return -ENOMEM;
1297
1298         chip->ds->priv = chip;
1299         chip->ds->ops = &lan9303_switch_ops;
1300         base = chip->phy_addr_base;
1301         chip->ds->phys_mii_mask = GENMASK(LAN9303_NUM_PORTS - 1 + base, base);
1302
1303         return dsa_register_switch(chip->ds);
1304 }
1305
1306 static int lan9303_probe_reset_gpio(struct lan9303 *chip,
1307                                      struct device_node *np)
1308 {
1309         chip->reset_gpio = devm_gpiod_get_optional(chip->dev, "reset",
1310                                                    GPIOD_OUT_HIGH);
1311         if (IS_ERR(chip->reset_gpio))
1312                 return PTR_ERR(chip->reset_gpio);
1313
1314         if (!chip->reset_gpio) {
1315                 dev_dbg(chip->dev, "No reset GPIO defined\n");
1316                 return 0;
1317         }
1318
1319         chip->reset_duration = 200;
1320
1321         if (np) {
1322                 of_property_read_u32(np, "reset-duration",
1323                                      &chip->reset_duration);
1324         } else {
1325                 dev_dbg(chip->dev, "reset duration defaults to 200 ms\n");
1326         }
1327
1328         /* A sane reset duration should not be longer than 1s */
1329         if (chip->reset_duration > 1000)
1330                 chip->reset_duration = 1000;
1331
1332         return 0;
1333 }
1334
1335 int lan9303_probe(struct lan9303 *chip, struct device_node *np)
1336 {
1337         int ret;
1338
1339         mutex_init(&chip->indirect_mutex);
1340         mutex_init(&chip->alr_mutex);
1341
1342         ret = lan9303_probe_reset_gpio(chip, np);
1343         if (ret)
1344                 return ret;
1345
1346         lan9303_handle_reset(chip);
1347
1348         ret = lan9303_check_device(chip);
1349         if (ret)
1350                 return ret;
1351
1352         ret = lan9303_register_switch(chip);
1353         if (ret) {
1354                 dev_dbg(chip->dev, "Failed to register switch: %d\n", ret);
1355                 return ret;
1356         }
1357
1358         return 0;
1359 }
1360 EXPORT_SYMBOL(lan9303_probe);
1361
1362 int lan9303_remove(struct lan9303 *chip)
1363 {
1364         int rc;
1365
1366         rc = lan9303_disable_processing(chip);
1367         if (rc != 0)
1368                 dev_warn(chip->dev, "shutting down failed\n");
1369
1370         dsa_unregister_switch(chip->ds);
1371
1372         /* assert reset to the whole device to prevent it from doing anything */
1373         gpiod_set_value_cansleep(chip->reset_gpio, 1);
1374         gpiod_unexport(chip->reset_gpio);
1375
1376         return 0;
1377 }
1378 EXPORT_SYMBOL(lan9303_remove);
1379
1380 MODULE_AUTHOR("Juergen Borleis <kernel@pengutronix.de>");
1381 MODULE_DESCRIPTION("Core driver for SMSC/Microchip LAN9303 three port ethernet switch");
1382 MODULE_LICENSE("GPL v2");