From: luizluca@gmail.com
To: netdev@vger.kernel.org
Cc: linus.walleij@linaro.org, andrew@lunn.ch,
vivien.didelot@gmail.com, f.fainelli@gmail.com,
olteanv@gmail.com, alsi@bang-olufsen.dk, arinc.unal@arinc9.com,
Luiz Angelo Daros de Luca <luizluca@gmail.com>
Subject: [PATCH net-next 07/13] net: dsa: rtl8365mb: rename rtl8365mb to rtl8367c
Date: Thu, 16 Dec 2021 17:13:36 -0300 [thread overview]
Message-ID: <20211216201342.25587-8-luizluca@gmail.com> (raw)
In-Reply-To: <20211216201342.25587-1-luizluca@gmail.com>
From: Luiz Angelo Daros de Luca <luizluca@gmail.com>
rtl8365mb refers to a single device supported by the driver.
The rtl8367c does not refer to any real device, but it is the
driver version name used by Realtek.
Tested-by: Arınç ÜNAL <arinc.unal@arinc9.com>
Signed-off-by: Luiz Angelo Daros de Luca <luizluca@gmail.com>
---
drivers/net/dsa/realtek/Kconfig | 9 +-
drivers/net/dsa/realtek/Makefile | 2 +-
drivers/net/dsa/realtek/realtek-smi.c | 4 +-
drivers/net/dsa/realtek/realtek.h | 2 +-
drivers/net/dsa/realtek/rtl8367c.c | 1321 ++++++++++++-------------
drivers/net/phy/realtek.c | 2 +-
6 files changed, 666 insertions(+), 674 deletions(-)
diff --git a/drivers/net/dsa/realtek/Kconfig b/drivers/net/dsa/realtek/Kconfig
index c002a84a00f5..874574db9177 100644
--- a/drivers/net/dsa/realtek/Kconfig
+++ b/drivers/net/dsa/realtek/Kconfig
@@ -16,14 +16,17 @@ config NET_DSA_REALTEK_SMI
help
Select to enable support for registering switches connected through SMI.
-config NET_DSA_REALTEK_RTL8365MB
- tristate "Realtek RTL8365MB switch subdriver"
+config NET_DSA_REALTEK_RTL8367C
+ tristate "Realtek RTL8367C switch subdriver"
default y
depends on NET_DSA_REALTEK
depends on NET_DSA_REALTEK_SMI
select NET_DSA_TAG_RTL8_4
help
- Select to enable support for Realtek RTL8365MB
+ Select to enable support for Realtek RTL8365MB-VC. This subdriver
+ might also support RTL8363NB, RTL8363NB-VB, RTL8363SC, RTL8363SC-VB, RTL8364NB,
+ RTL8364NB-VB, RTL8366SC, RTL8367RB-VB, RTL8367S, RTL8367SB, RTL8370MB, RTL8310SR
+ in the future.
config NET_DSA_REALTEK_RTL8366RB
tristate "Realtek RTL8366RB switch subdriver"
diff --git a/drivers/net/dsa/realtek/Makefile b/drivers/net/dsa/realtek/Makefile
index efb9568077f5..84d5ab062c89 100644
--- a/drivers/net/dsa/realtek/Makefile
+++ b/drivers/net/dsa/realtek/Makefile
@@ -2,4 +2,4 @@
obj-$(CONFIG_NET_DSA_REALTEK_SMI) += realtek-smi.o
obj-$(CONFIG_NET_DSA_REALTEK_RTL8366RB) += rtl8366.o
rtl8366-objs := rtl8366-core.o rtl8366rb.o
-obj-$(CONFIG_NET_DSA_REALTEK_RTL8365MB) += rtl8367c.o
+obj-$(CONFIG_NET_DSA_REALTEK_RTL8367C) += rtl8367c.o
diff --git a/drivers/net/dsa/realtek/realtek-smi.c b/drivers/net/dsa/realtek/realtek-smi.c
index f10acd7d3636..258f90956cec 100644
--- a/drivers/net/dsa/realtek/realtek-smi.c
+++ b/drivers/net/dsa/realtek/realtek-smi.c
@@ -506,10 +506,10 @@ static const struct of_device_id realtek_smi_of_match[] = {
.compatible = "realtek,rtl8366s",
.data = NULL,
},
-#if IS_ENABLED(CONFIG_NET_DSA_REALTEK_RTL8365MB)
+#if IS_ENABLED(CONFIG_NET_DSA_REALTEK_RTL8367C)
{
.compatible = "realtek,rtl8365mb",
- .data = &rtl8365mb_variant,
+ .data = &rtl8367c_variant,
},
#endif
{ /* sentinel */ },
diff --git a/drivers/net/dsa/realtek/realtek.h b/drivers/net/dsa/realtek/realtek.h
index daca0c0b7ea2..976cb7823c92 100644
--- a/drivers/net/dsa/realtek/realtek.h
+++ b/drivers/net/dsa/realtek/realtek.h
@@ -134,6 +134,6 @@ int rtl8366_get_sset_count(struct dsa_switch *ds, int port, int sset);
void rtl8366_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *data);
extern const struct realtek_variant rtl8366rb_variant;
-extern const struct realtek_variant rtl8365mb_variant;
+extern const struct realtek_variant rtl8367c_variant;
#endif /* _REALTEK_SMI_H */
diff --git a/drivers/net/dsa/realtek/rtl8367c.c b/drivers/net/dsa/realtek/rtl8367c.c
index 488b17a68226..98ec793a82bc 100644
--- a/drivers/net/dsa/realtek/rtl8367c.c
+++ b/drivers/net/dsa/realtek/rtl8367c.c
@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0
-/* Realtek SMI subdriver for the Realtek RTL8365MB-VC ethernet switch.
+/* Realtek SMI subdriver for the Realtek RTL8367C ethernet switches.
*
* Copyright (C) 2021 Alvin Šipraga <alsi@bang-olufsen.dk>
* Copyright (C) 2021 Michael Rasmussen <mir@bang-olufsen.dk>
@@ -52,19 +52,7 @@
* the driver will manually reprogram some registers using jam tables to reach
* an initial state defined by the vendor driver.
*
- * This Linux driver is written based on an OS-agnostic vendor driver from
- * Realtek. The reference GPL-licensed sources can be found in the OpenWrt
- * source tree under the name rtl8367c. The vendor driver claims to support a
- * number of similar switch controllers from Realtek, but the only hardware we
- * have is the RTL8365MB-VC. Moreover, there does not seem to be any chip under
- * the name RTL8367C. Although one wishes that the 'C' stood for some kind of
- * common hardware revision, there exist examples of chips with the suffix -VC
- * which are explicitly not supported by the rtl8367c driver and which instead
- * require the rtl8367d vendor driver. With all this uncertainty, the driver has
- * been modestly named rtl8365mb. Future implementors may wish to rename things
- * accordingly.
- *
- * In the same family of chips, some carry up to 8 user ports and up to 2
+ * In this family of chips, some carry up to 8 user ports and up to 2
* extension ports. Where possible this driver tries to make things generic, but
* more work must be done to support these configurations. According to
* documentation from Realtek, the family should include the following chips:
@@ -102,202 +90,203 @@
#include "realtek.h"
/* Chip-specific data and limits */
-#define RTL8365MB_CHIP_ID_8365MB_VC 0x6367
-#define RTL8365MB_CPU_PORT_NUM_8365MB_VC 6
-#define RTL8365MB_LEARN_LIMIT_MAX_8365MB_VC 2112
+#define RTL8367C_CHIP_ID_8365MB_VC 0x6367
+#define RTL8367C_CPU_PORT_NUM_8365MB_VC 6
+
+#define RTL8367C_LEARN_LIMIT_MAX 2112
/* Family-specific data and limits */
-#define RTL8365MB_PHYADDRMAX 7
-#define RTL8365MB_NUM_PHYREGS 32
-#define RTL8365MB_PHYREGMAX (RTL8365MB_NUM_PHYREGS - 1)
-#define RTL8365MB_MAX_NUM_PORTS (RTL8365MB_CPU_PORT_NUM_8365MB_VC + 1)
+#define RTL8367C_PHYADDRMAX 7
+#define RTL8367C_NUM_PHYREGS 32
+#define RTL8367C_PHYREGMAX (RTL8367C_NUM_PHYREGS - 1)
+#define RTL8367C_MAX_NUM_PORTS (RTL8367C_CPU_PORT_NUM_8365MB_VC + 1)
/* Chip identification registers */
-#define RTL8365MB_CHIP_ID_REG 0x1300
+#define RTL8367C_CHIP_ID_REG 0x1300
-#define RTL8365MB_CHIP_VER_REG 0x1301
+#define RTL8367C_CHIP_VER_REG 0x1301
-#define RTL8365MB_MAGIC_REG 0x13C2
-#define RTL8365MB_MAGIC_VALUE 0x0249
+#define RTL8367C_MAGIC_REG 0x13C2
+#define RTL8367C_MAGIC_VALUE 0x0249
/* Chip reset register */
-#define RTL8365MB_CHIP_RESET_REG 0x1322
-#define RTL8365MB_CHIP_RESET_SW_MASK 0x0002
-#define RTL8365MB_CHIP_RESET_HW_MASK 0x0001
+#define RTL8367C_CHIP_RESET_REG 0x1322
+#define RTL8367C_CHIP_RESET_SW_MASK 0x0002
+#define RTL8367C_CHIP_RESET_HW_MASK 0x0001
/* Interrupt polarity register */
-#define RTL8365MB_INTR_POLARITY_REG 0x1100
-#define RTL8365MB_INTR_POLARITY_MASK 0x0001
-#define RTL8365MB_INTR_POLARITY_HIGH 0
-#define RTL8365MB_INTR_POLARITY_LOW 1
+#define RTL8367C_INTR_POLARITY_REG 0x1100
+#define RTL8367C_INTR_POLARITY_MASK 0x0001
+#define RTL8367C_INTR_POLARITY_HIGH 0
+#define RTL8367C_INTR_POLARITY_LOW 1
/* Interrupt control/status register - enable/check specific interrupt types */
-#define RTL8365MB_INTR_CTRL_REG 0x1101
-#define RTL8365MB_INTR_STATUS_REG 0x1102
-#define RTL8365MB_INTR_SLIENT_START_2_MASK 0x1000
-#define RTL8365MB_INTR_SLIENT_START_MASK 0x0800
-#define RTL8365MB_INTR_ACL_ACTION_MASK 0x0200
-#define RTL8365MB_INTR_CABLE_DIAG_FIN_MASK 0x0100
-#define RTL8365MB_INTR_INTERRUPT_8051_MASK 0x0080
-#define RTL8365MB_INTR_LOOP_DETECTION_MASK 0x0040
-#define RTL8365MB_INTR_GREEN_TIMER_MASK 0x0020
-#define RTL8365MB_INTR_SPECIAL_CONGEST_MASK 0x0010
-#define RTL8365MB_INTR_SPEED_CHANGE_MASK 0x0008
-#define RTL8365MB_INTR_LEARN_OVER_MASK 0x0004
-#define RTL8365MB_INTR_METER_EXCEEDED_MASK 0x0002
-#define RTL8365MB_INTR_LINK_CHANGE_MASK 0x0001
-#define RTL8365MB_INTR_ALL_MASK \
- (RTL8365MB_INTR_SLIENT_START_2_MASK | \
- RTL8365MB_INTR_SLIENT_START_MASK | \
- RTL8365MB_INTR_ACL_ACTION_MASK | \
- RTL8365MB_INTR_CABLE_DIAG_FIN_MASK | \
- RTL8365MB_INTR_INTERRUPT_8051_MASK | \
- RTL8365MB_INTR_LOOP_DETECTION_MASK | \
- RTL8365MB_INTR_GREEN_TIMER_MASK | \
- RTL8365MB_INTR_SPECIAL_CONGEST_MASK | \
- RTL8365MB_INTR_SPEED_CHANGE_MASK | \
- RTL8365MB_INTR_LEARN_OVER_MASK | \
- RTL8365MB_INTR_METER_EXCEEDED_MASK | \
- RTL8365MB_INTR_LINK_CHANGE_MASK)
+#define RTL8367C_INTR_CTRL_REG 0x1101
+#define RTL8367C_INTR_STATUS_REG 0x1102
+#define RTL8367C_INTR_SLIENT_START_2_MASK 0x1000
+#define RTL8367C_INTR_SLIENT_START_MASK 0x0800
+#define RTL8367C_INTR_ACL_ACTION_MASK 0x0200
+#define RTL8367C_INTR_CABLE_DIAG_FIN_MASK 0x0100
+#define RTL8367C_INTR_INTERRUPT_8051_MASK 0x0080
+#define RTL8367C_INTR_LOOP_DETECTION_MASK 0x0040
+#define RTL8367C_INTR_GREEN_TIMER_MASK 0x0020
+#define RTL8367C_INTR_SPECIAL_CONGEST_MASK 0x0010
+#define RTL8367C_INTR_SPEED_CHANGE_MASK 0x0008
+#define RTL8367C_INTR_LEARN_OVER_MASK 0x0004
+#define RTL8367C_INTR_METER_EXCEEDED_MASK 0x0002
+#define RTL8367C_INTR_LINK_CHANGE_MASK 0x0001
+#define RTL8367C_INTR_ALL_MASK \
+ (RTL8367C_INTR_SLIENT_START_2_MASK | \
+ RTL8367C_INTR_SLIENT_START_MASK | \
+ RTL8367C_INTR_ACL_ACTION_MASK | \
+ RTL8367C_INTR_CABLE_DIAG_FIN_MASK | \
+ RTL8367C_INTR_INTERRUPT_8051_MASK | \
+ RTL8367C_INTR_LOOP_DETECTION_MASK | \
+ RTL8367C_INTR_GREEN_TIMER_MASK | \
+ RTL8367C_INTR_SPECIAL_CONGEST_MASK | \
+ RTL8367C_INTR_SPEED_CHANGE_MASK | \
+ RTL8367C_INTR_LEARN_OVER_MASK | \
+ RTL8367C_INTR_METER_EXCEEDED_MASK | \
+ RTL8367C_INTR_LINK_CHANGE_MASK)
/* Per-port interrupt type status registers */
-#define RTL8365MB_PORT_LINKDOWN_IND_REG 0x1106
-#define RTL8365MB_PORT_LINKDOWN_IND_MASK 0x07FF
+#define RTL8367C_PORT_LINKDOWN_IND_REG 0x1106
+#define RTL8367C_PORT_LINKDOWN_IND_MASK 0x07FF
-#define RTL8365MB_PORT_LINKUP_IND_REG 0x1107
-#define RTL8365MB_PORT_LINKUP_IND_MASK 0x07FF
+#define RTL8367C_PORT_LINKUP_IND_REG 0x1107
+#define RTL8367C_PORT_LINKUP_IND_MASK 0x07FF
/* PHY indirect access registers */
-#define RTL8365MB_INDIRECT_ACCESS_CTRL_REG 0x1F00
-#define RTL8365MB_INDIRECT_ACCESS_CTRL_RW_MASK 0x0002
-#define RTL8365MB_INDIRECT_ACCESS_CTRL_RW_READ 0
-#define RTL8365MB_INDIRECT_ACCESS_CTRL_RW_WRITE 1
-#define RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_MASK 0x0001
-#define RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_VALUE 1
-#define RTL8365MB_INDIRECT_ACCESS_STATUS_REG 0x1F01
-#define RTL8365MB_INDIRECT_ACCESS_ADDRESS_REG 0x1F02
-#define RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_5_1_MASK GENMASK(4, 0)
-#define RTL8365MB_INDIRECT_ACCESS_ADDRESS_PHYNUM_MASK GENMASK(7, 5)
-#define RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_9_6_MASK GENMASK(11, 8)
-#define RTL8365MB_PHY_BASE 0x2000
-#define RTL8365MB_INDIRECT_ACCESS_WRITE_DATA_REG 0x1F03
-#define RTL8365MB_INDIRECT_ACCESS_READ_DATA_REG 0x1F04
+#define RTL8367C_INDIRECT_ACCESS_CTRL_REG 0x1F00
+#define RTL8367C_INDIRECT_ACCESS_CTRL_RW_MASK 0x0002
+#define RTL8367C_INDIRECT_ACCESS_CTRL_RW_READ 0
+#define RTL8367C_INDIRECT_ACCESS_CTRL_RW_WRITE 1
+#define RTL8367C_INDIRECT_ACCESS_CTRL_CMD_MASK 0x0001
+#define RTL8367C_INDIRECT_ACCESS_CTRL_CMD_VALUE 1
+#define RTL8367C_INDIRECT_ACCESS_STATUS_REG 0x1F01
+#define RTL8367C_INDIRECT_ACCESS_ADDRESS_REG 0x1F02
+#define RTL8367C_INDIRECT_ACCESS_ADDRESS_OCPADR_5_1_MASK GENMASK(4, 0)
+#define RTL8367C_INDIRECT_ACCESS_ADDRESS_PHYNUM_MASK GENMASK(7, 5)
+#define RTL8367C_INDIRECT_ACCESS_ADDRESS_OCPADR_9_6_MASK GENMASK(11, 8)
+#define RTL8367C_PHY_BASE 0x2000
+#define RTL8367C_INDIRECT_ACCESS_WRITE_DATA_REG 0x1F03
+#define RTL8367C_INDIRECT_ACCESS_READ_DATA_REG 0x1F04
/* PHY OCP address prefix register */
-#define RTL8365MB_GPHY_OCP_MSB_0_REG 0x1D15
-#define RTL8365MB_GPHY_OCP_MSB_0_CFG_CPU_OCPADR_MASK 0x0FC0
-#define RTL8365MB_PHY_OCP_ADDR_PREFIX_MASK 0xFC00
+#define RTL8367C_GPHY_OCP_MSB_0_REG 0x1D15
+#define RTL8367C_GPHY_OCP_MSB_0_CFG_CPU_OCPADR_MASK 0x0FC0
+#define RTL8367C_PHY_OCP_ADDR_PREFIX_MASK 0xFC00
/* The PHY OCP addresses of PHY registers 0~31 start here */
-#define RTL8365MB_PHY_OCP_ADDR_PHYREG_BASE 0xA400
+#define RTL8367C_PHY_OCP_ADDR_PHYREG_BASE 0xA400
/* EXT port interface mode values - used in DIGITAL_INTERFACE_SELECT */
-#define RTL8365MB_EXT_PORT_MODE_DISABLE 0
-#define RTL8365MB_EXT_PORT_MODE_RGMII 1
-#define RTL8365MB_EXT_PORT_MODE_MII_MAC 2
-#define RTL8365MB_EXT_PORT_MODE_MII_PHY 3
-#define RTL8365MB_EXT_PORT_MODE_TMII_MAC 4
-#define RTL8365MB_EXT_PORT_MODE_TMII_PHY 5
-#define RTL8365MB_EXT_PORT_MODE_GMII 6
-#define RTL8365MB_EXT_PORT_MODE_RMII_MAC 7
-#define RTL8365MB_EXT_PORT_MODE_RMII_PHY 8
-#define RTL8365MB_EXT_PORT_MODE_SGMII 9
-#define RTL8365MB_EXT_PORT_MODE_HSGMII 10
-#define RTL8365MB_EXT_PORT_MODE_1000X_100FX 11
-#define RTL8365MB_EXT_PORT_MODE_1000X 12
-#define RTL8365MB_EXT_PORT_MODE_100FX 13
+#define RTL8367C_EXT_PORT_MODE_DISABLE 0
+#define RTL8367C_EXT_PORT_MODE_RGMII 1
+#define RTL8367C_EXT_PORT_MODE_MII_MAC 2
+#define RTL8367C_EXT_PORT_MODE_MII_PHY 3
+#define RTL8367C_EXT_PORT_MODE_TMII_MAC 4
+#define RTL8367C_EXT_PORT_MODE_TMII_PHY 5
+#define RTL8367C_EXT_PORT_MODE_GMII 6
+#define RTL8367C_EXT_PORT_MODE_RMII_MAC 7
+#define RTL8367C_EXT_PORT_MODE_RMII_PHY 8
+#define RTL8367C_EXT_PORT_MODE_SGMII 9
+#define RTL8367C_EXT_PORT_MODE_HSGMII 10
+#define RTL8367C_EXT_PORT_MODE_1000X_100FX 11
+#define RTL8367C_EXT_PORT_MODE_1000X 12
+#define RTL8367C_EXT_PORT_MODE_100FX 13
/* EXT port interface mode configuration registers 0~1 */
-#define RTL8365MB_DIGITAL_INTERFACE_SELECT_REG0 0x1305
-#define RTL8365MB_DIGITAL_INTERFACE_SELECT_REG1 0x13C3
-#define RTL8365MB_DIGITAL_INTERFACE_SELECT_REG(_extport) \
- (RTL8365MB_DIGITAL_INTERFACE_SELECT_REG0 + \
+#define RTL8367C_DIGITAL_INTERFACE_SELECT_REG0 0x1305
+#define RTL8367C_DIGITAL_INTERFACE_SELECT_REG1 0x13C3
+#define RTL8367C_DIGITAL_INTERFACE_SELECT_REG(_extport) \
+ (RTL8367C_DIGITAL_INTERFACE_SELECT_REG0 + \
((_extport) >> 1) * (0x13C3 - 0x1305))
-#define RTL8365MB_DIGITAL_INTERFACE_SELECT_MODE_MASK(_extport) \
+#define RTL8367C_DIGITAL_INTERFACE_SELECT_MODE_MASK(_extport) \
(0xF << (((_extport) % 2)))
-#define RTL8365MB_DIGITAL_INTERFACE_SELECT_MODE_OFFSET(_extport) \
+#define RTL8367C_DIGITAL_INTERFACE_SELECT_MODE_OFFSET(_extport) \
(((_extport) % 2) * 4)
/* EXT port RGMII TX/RX delay configuration registers 1~2 */
-#define RTL8365MB_EXT_RGMXF_REG1 0x1307
-#define RTL8365MB_EXT_RGMXF_REG2 0x13C5
-#define RTL8365MB_EXT_RGMXF_REG(_extport) \
- (RTL8365MB_EXT_RGMXF_REG1 + \
+#define RTL8367C_EXT_RGMXF_REG1 0x1307
+#define RTL8367C_EXT_RGMXF_REG2 0x13C5
+#define RTL8367C_EXT_RGMXF_REG(_extport) \
+ (RTL8367C_EXT_RGMXF_REG1 + \
(((_extport) >> 1) * (0x13C5 - 0x1307)))
-#define RTL8365MB_EXT_RGMXF_RXDELAY_MASK 0x0007
-#define RTL8365MB_EXT_RGMXF_TXDELAY_MASK 0x0008
+#define RTL8367C_EXT_RGMXF_RXDELAY_MASK 0x0007
+#define RTL8367C_EXT_RGMXF_TXDELAY_MASK 0x0008
/* External port speed values - used in DIGITAL_INTERFACE_FORCE */
-#define RTL8365MB_PORT_SPEED_10M 0
-#define RTL8365MB_PORT_SPEED_100M 1
-#define RTL8365MB_PORT_SPEED_1000M 2
+#define RTL8367C_PORT_SPEED_10M 0
+#define RTL8367C_PORT_SPEED_100M 1
+#define RTL8367C_PORT_SPEED_1000M 2
/* EXT port force configuration registers 0~2 */
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_REG0 0x1310
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_REG1 0x1311
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_REG2 0x13C4
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_REG(_extport) \
- (RTL8365MB_DIGITAL_INTERFACE_FORCE_REG0 + \
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_REG0 0x1310
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_REG1 0x1311
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_REG2 0x13C4
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_REG(_extport) \
+ (RTL8367C_DIGITAL_INTERFACE_FORCE_REG0 + \
((_extport) & 0x1) + \
((((_extport) >> 1) & 0x1) * (0x13C4 - 0x1310)))
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_EN_MASK 0x1000
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_NWAY_MASK 0x0080
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_TXPAUSE_MASK 0x0040
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_RXPAUSE_MASK 0x0020
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_LINK_MASK 0x0010
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_DUPLEX_MASK 0x0004
-#define RTL8365MB_DIGITAL_INTERFACE_FORCE_SPEED_MASK 0x0003
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_EN_MASK 0x1000
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_NWAY_MASK 0x0080
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_TXPAUSE_MASK 0x0040
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_RXPAUSE_MASK 0x0020
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_LINK_MASK 0x0010
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_DUPLEX_MASK 0x0004
+#define RTL8367C_DIGITAL_INTERFACE_FORCE_SPEED_MASK 0x0003
/* CPU port mask register - controls which ports are treated as CPU ports */
-#define RTL8365MB_CPU_PORT_MASK_REG 0x1219
-#define RTL8365MB_CPU_PORT_MASK_MASK 0x07FF
+#define RTL8367C_CPU_PORT_MASK_REG 0x1219
+#define RTL8367C_CPU_PORT_MASK_MASK 0x07FF
/* CPU control register */
-#define RTL8365MB_CPU_CTRL_REG 0x121A
-#define RTL8365MB_CPU_CTRL_TRAP_PORT_EXT_MASK 0x0400
-#define RTL8365MB_CPU_CTRL_TAG_FORMAT_MASK 0x0200
-#define RTL8365MB_CPU_CTRL_RXBYTECOUNT_MASK 0x0080
-#define RTL8365MB_CPU_CTRL_TAG_POSITION_MASK 0x0040
-#define RTL8365MB_CPU_CTRL_TRAP_PORT_MASK 0x0038
-#define RTL8365MB_CPU_CTRL_INSERTMODE_MASK 0x0006
-#define RTL8365MB_CPU_CTRL_EN_MASK 0x0001
+#define RTL8367C_CPU_CTRL_REG 0x121A
+#define RTL8367C_CPU_CTRL_TRAP_PORT_EXT_MASK 0x0400
+#define RTL8367C_CPU_CTRL_TAG_FORMAT_MASK 0x0200
+#define RTL8367C_CPU_CTRL_RXBYTECOUNT_MASK 0x0080
+#define RTL8367C_CPU_CTRL_TAG_POSITION_MASK 0x0040
+#define RTL8367C_CPU_CTRL_TRAP_PORT_MASK 0x0038
+#define RTL8367C_CPU_CTRL_INSERTMODE_MASK 0x0006
+#define RTL8367C_CPU_CTRL_EN_MASK 0x0001
/* Maximum packet length register */
-#define RTL8365MB_CFG0_MAX_LEN_REG 0x088C
-#define RTL8365MB_CFG0_MAX_LEN_MASK 0x3FFF
+#define RTL8367C_CFG0_MAX_LEN_REG 0x088C
+#define RTL8367C_CFG0_MAX_LEN_MASK 0x3FFF
/* Port learning limit registers */
-#define RTL8365MB_LUT_PORT_LEARN_LIMIT_BASE 0x0A20
-#define RTL8365MB_LUT_PORT_LEARN_LIMIT_REG(_physport) \
- (RTL8365MB_LUT_PORT_LEARN_LIMIT_BASE + (_physport))
+#define RTL8367C_LUT_PORT_LEARN_LIMIT_BASE 0x0A20
+#define RTL8367C_LUT_PORT_LEARN_LIMIT_REG(_physport) \
+ (RTL8367C_LUT_PORT_LEARN_LIMIT_BASE + (_physport))
/* Port isolation (forwarding mask) registers */
-#define RTL8365MB_PORT_ISOLATION_REG_BASE 0x08A2
-#define RTL8365MB_PORT_ISOLATION_REG(_physport) \
- (RTL8365MB_PORT_ISOLATION_REG_BASE + (_physport))
-#define RTL8365MB_PORT_ISOLATION_MASK 0x07FF
+#define RTL8367C_PORT_ISOLATION_REG_BASE 0x08A2
+#define RTL8367C_PORT_ISOLATION_REG(_physport) \
+ (RTL8367C_PORT_ISOLATION_REG_BASE + (_physport))
+#define RTL8367C_PORT_ISOLATION_MASK 0x07FF
/* MSTP port state registers - indexed by tree instance */
-#define RTL8365MB_MSTI_CTRL_BASE 0x0A00
-#define RTL8365MB_MSTI_CTRL_REG(_msti, _physport) \
- (RTL8365MB_MSTI_CTRL_BASE + ((_msti) << 1) + ((_physport) >> 3))
-#define RTL8365MB_MSTI_CTRL_PORT_STATE_OFFSET(_physport) ((_physport) << 1)
-#define RTL8365MB_MSTI_CTRL_PORT_STATE_MASK(_physport) \
- (0x3 << RTL8365MB_MSTI_CTRL_PORT_STATE_OFFSET((_physport)))
+#define RTL8367C_MSTI_CTRL_BASE 0x0A00
+#define RTL8367C_MSTI_CTRL_REG(_msti, _physport) \
+ (RTL8367C_MSTI_CTRL_BASE + ((_msti) << 1) + ((_physport) >> 3))
+#define RTL8367C_MSTI_CTRL_PORT_STATE_OFFSET(_physport) ((_physport) << 1)
+#define RTL8367C_MSTI_CTRL_PORT_STATE_MASK(_physport) \
+ (0x3 << RTL8367C_MSTI_CTRL_PORT_STATE_OFFSET((_physport)))
/* MIB counter value registers */
-#define RTL8365MB_MIB_COUNTER_BASE 0x1000
-#define RTL8365MB_MIB_COUNTER_REG(_x) (RTL8365MB_MIB_COUNTER_BASE + (_x))
+#define RTL8367C_MIB_COUNTER_BASE 0x1000
+#define RTL8367C_MIB_COUNTER_REG(_x) (RTL8367C_MIB_COUNTER_BASE + (_x))
/* MIB counter address register */
-#define RTL8365MB_MIB_ADDRESS_REG 0x1004
-#define RTL8365MB_MIB_ADDRESS_PORT_OFFSET 0x007C
-#define RTL8365MB_MIB_ADDRESS(_p, _x) \
- (((RTL8365MB_MIB_ADDRESS_PORT_OFFSET) * (_p) + (_x)) >> 2)
+#define RTL8367C_MIB_ADDRESS_REG 0x1004
+#define RTL8367C_MIB_ADDRESS_PORT_OFFSET 0x007C
+#define RTL8367C_MIB_ADDRESS(_p, _x) \
+ (((RTL8367C_MIB_ADDRESS_PORT_OFFSET) * (_p) + (_x)) >> 2)
-#define RTL8365MB_MIB_CTRL0_REG 0x1005
-#define RTL8365MB_MIB_CTRL0_RESET_MASK 0x0002
-#define RTL8365MB_MIB_CTRL0_BUSY_MASK 0x0001
+#define RTL8367C_MIB_CTRL0_REG 0x1005
+#define RTL8367C_MIB_CTRL0_RESET_MASK 0x0002
+#define RTL8367C_MIB_CTRL0_BUSY_MASK 0x0001
/* The DSA callback .get_stats64 runs in atomic context, so we are not allowed
* to block. On the other hand, accessing MIB counters absolutely requires us to
@@ -305,149 +294,149 @@
* asynchronously and updates some private data, which the callback can then
* fetch atomically. Three seconds should be a good enough polling interval.
*/
-#define RTL8365MB_STATS_INTERVAL_JIFFIES (3 * HZ)
-
-enum rtl8365mb_mib_counter_index {
- RTL8365MB_MIB_ifInOctets,
- RTL8365MB_MIB_dot3StatsFCSErrors,
- RTL8365MB_MIB_dot3StatsSymbolErrors,
- RTL8365MB_MIB_dot3InPauseFrames,
- RTL8365MB_MIB_dot3ControlInUnknownOpcodes,
- RTL8365MB_MIB_etherStatsFragments,
- RTL8365MB_MIB_etherStatsJabbers,
- RTL8365MB_MIB_ifInUcastPkts,
- RTL8365MB_MIB_etherStatsDropEvents,
- RTL8365MB_MIB_ifInMulticastPkts,
- RTL8365MB_MIB_ifInBroadcastPkts,
- RTL8365MB_MIB_inMldChecksumError,
- RTL8365MB_MIB_inIgmpChecksumError,
- RTL8365MB_MIB_inMldSpecificQuery,
- RTL8365MB_MIB_inMldGeneralQuery,
- RTL8365MB_MIB_inIgmpSpecificQuery,
- RTL8365MB_MIB_inIgmpGeneralQuery,
- RTL8365MB_MIB_inMldLeaves,
- RTL8365MB_MIB_inIgmpLeaves,
- RTL8365MB_MIB_etherStatsOctets,
- RTL8365MB_MIB_etherStatsUnderSizePkts,
- RTL8365MB_MIB_etherOversizeStats,
- RTL8365MB_MIB_etherStatsPkts64Octets,
- RTL8365MB_MIB_etherStatsPkts65to127Octets,
- RTL8365MB_MIB_etherStatsPkts128to255Octets,
- RTL8365MB_MIB_etherStatsPkts256to511Octets,
- RTL8365MB_MIB_etherStatsPkts512to1023Octets,
- RTL8365MB_MIB_etherStatsPkts1024to1518Octets,
- RTL8365MB_MIB_ifOutOctets,
- RTL8365MB_MIB_dot3StatsSingleCollisionFrames,
- RTL8365MB_MIB_dot3StatsMultipleCollisionFrames,
- RTL8365MB_MIB_dot3StatsDeferredTransmissions,
- RTL8365MB_MIB_dot3StatsLateCollisions,
- RTL8365MB_MIB_etherStatsCollisions,
- RTL8365MB_MIB_dot3StatsExcessiveCollisions,
- RTL8365MB_MIB_dot3OutPauseFrames,
- RTL8365MB_MIB_ifOutDiscards,
- RTL8365MB_MIB_dot1dTpPortInDiscards,
- RTL8365MB_MIB_ifOutUcastPkts,
- RTL8365MB_MIB_ifOutMulticastPkts,
- RTL8365MB_MIB_ifOutBroadcastPkts,
- RTL8365MB_MIB_outOampduPkts,
- RTL8365MB_MIB_inOampduPkts,
- RTL8365MB_MIB_inIgmpJoinsSuccess,
- RTL8365MB_MIB_inIgmpJoinsFail,
- RTL8365MB_MIB_inMldJoinsSuccess,
- RTL8365MB_MIB_inMldJoinsFail,
- RTL8365MB_MIB_inReportSuppressionDrop,
- RTL8365MB_MIB_inLeaveSuppressionDrop,
- RTL8365MB_MIB_outIgmpReports,
- RTL8365MB_MIB_outIgmpLeaves,
- RTL8365MB_MIB_outIgmpGeneralQuery,
- RTL8365MB_MIB_outIgmpSpecificQuery,
- RTL8365MB_MIB_outMldReports,
- RTL8365MB_MIB_outMldLeaves,
- RTL8365MB_MIB_outMldGeneralQuery,
- RTL8365MB_MIB_outMldSpecificQuery,
- RTL8365MB_MIB_inKnownMulticastPkts,
- RTL8365MB_MIB_END,
+#define RTL8367C_STATS_INTERVAL_JIFFIES (3 * HZ)
+
+enum rtl8367c_mib_counter_index {
+ RTL8367C_MIB_ifInOctets,
+ RTL8367C_MIB_dot3StatsFCSErrors,
+ RTL8367C_MIB_dot3StatsSymbolErrors,
+ RTL8367C_MIB_dot3InPauseFrames,
+ RTL8367C_MIB_dot3ControlInUnknownOpcodes,
+ RTL8367C_MIB_etherStatsFragments,
+ RTL8367C_MIB_etherStatsJabbers,
+ RTL8367C_MIB_ifInUcastPkts,
+ RTL8367C_MIB_etherStatsDropEvents,
+ RTL8367C_MIB_ifInMulticastPkts,
+ RTL8367C_MIB_ifInBroadcastPkts,
+ RTL8367C_MIB_inMldChecksumError,
+ RTL8367C_MIB_inIgmpChecksumError,
+ RTL8367C_MIB_inMldSpecificQuery,
+ RTL8367C_MIB_inMldGeneralQuery,
+ RTL8367C_MIB_inIgmpSpecificQuery,
+ RTL8367C_MIB_inIgmpGeneralQuery,
+ RTL8367C_MIB_inMldLeaves,
+ RTL8367C_MIB_inIgmpLeaves,
+ RTL8367C_MIB_etherStatsOctets,
+ RTL8367C_MIB_etherStatsUnderSizePkts,
+ RTL8367C_MIB_etherOversizeStats,
+ RTL8367C_MIB_etherStatsPkts64Octets,
+ RTL8367C_MIB_etherStatsPkts65to127Octets,
+ RTL8367C_MIB_etherStatsPkts128to255Octets,
+ RTL8367C_MIB_etherStatsPkts256to511Octets,
+ RTL8367C_MIB_etherStatsPkts512to1023Octets,
+ RTL8367C_MIB_etherStatsPkts1024to1518Octets,
+ RTL8367C_MIB_ifOutOctets,
+ RTL8367C_MIB_dot3StatsSingleCollisionFrames,
+ RTL8367C_MIB_dot3StatsMultipleCollisionFrames,
+ RTL8367C_MIB_dot3StatsDeferredTransmissions,
+ RTL8367C_MIB_dot3StatsLateCollisions,
+ RTL8367C_MIB_etherStatsCollisions,
+ RTL8367C_MIB_dot3StatsExcessiveCollisions,
+ RTL8367C_MIB_dot3OutPauseFrames,
+ RTL8367C_MIB_ifOutDiscards,
+ RTL8367C_MIB_dot1dTpPortInDiscards,
+ RTL8367C_MIB_ifOutUcastPkts,
+ RTL8367C_MIB_ifOutMulticastPkts,
+ RTL8367C_MIB_ifOutBroadcastPkts,
+ RTL8367C_MIB_outOampduPkts,
+ RTL8367C_MIB_inOampduPkts,
+ RTL8367C_MIB_inIgmpJoinsSuccess,
+ RTL8367C_MIB_inIgmpJoinsFail,
+ RTL8367C_MIB_inMldJoinsSuccess,
+ RTL8367C_MIB_inMldJoinsFail,
+ RTL8367C_MIB_inReportSuppressionDrop,
+ RTL8367C_MIB_inLeaveSuppressionDrop,
+ RTL8367C_MIB_outIgmpReports,
+ RTL8367C_MIB_outIgmpLeaves,
+ RTL8367C_MIB_outIgmpGeneralQuery,
+ RTL8367C_MIB_outIgmpSpecificQuery,
+ RTL8367C_MIB_outMldReports,
+ RTL8367C_MIB_outMldLeaves,
+ RTL8367C_MIB_outMldGeneralQuery,
+ RTL8367C_MIB_outMldSpecificQuery,
+ RTL8367C_MIB_inKnownMulticastPkts,
+ RTL8367C_MIB_END,
};
-struct rtl8365mb_mib_counter {
+struct rtl8367c_mib_counter {
u32 offset;
u32 length;
const char *name;
};
-#define RTL8365MB_MAKE_MIB_COUNTER(_offset, _length, _name) \
- [RTL8365MB_MIB_ ## _name] = { _offset, _length, #_name }
-
-static struct rtl8365mb_mib_counter rtl8365mb_mib_counters[] = {
- RTL8365MB_MAKE_MIB_COUNTER(0, 4, ifInOctets),
- RTL8365MB_MAKE_MIB_COUNTER(4, 2, dot3StatsFCSErrors),
- RTL8365MB_MAKE_MIB_COUNTER(6, 2, dot3StatsSymbolErrors),
- RTL8365MB_MAKE_MIB_COUNTER(8, 2, dot3InPauseFrames),
- RTL8365MB_MAKE_MIB_COUNTER(10, 2, dot3ControlInUnknownOpcodes),
- RTL8365MB_MAKE_MIB_COUNTER(12, 2, etherStatsFragments),
- RTL8365MB_MAKE_MIB_COUNTER(14, 2, etherStatsJabbers),
- RTL8365MB_MAKE_MIB_COUNTER(16, 2, ifInUcastPkts),
- RTL8365MB_MAKE_MIB_COUNTER(18, 2, etherStatsDropEvents),
- RTL8365MB_MAKE_MIB_COUNTER(20, 2, ifInMulticastPkts),
- RTL8365MB_MAKE_MIB_COUNTER(22, 2, ifInBroadcastPkts),
- RTL8365MB_MAKE_MIB_COUNTER(24, 2, inMldChecksumError),
- RTL8365MB_MAKE_MIB_COUNTER(26, 2, inIgmpChecksumError),
- RTL8365MB_MAKE_MIB_COUNTER(28, 2, inMldSpecificQuery),
- RTL8365MB_MAKE_MIB_COUNTER(30, 2, inMldGeneralQuery),
- RTL8365MB_MAKE_MIB_COUNTER(32, 2, inIgmpSpecificQuery),
- RTL8365MB_MAKE_MIB_COUNTER(34, 2, inIgmpGeneralQuery),
- RTL8365MB_MAKE_MIB_COUNTER(36, 2, inMldLeaves),
- RTL8365MB_MAKE_MIB_COUNTER(38, 2, inIgmpLeaves),
- RTL8365MB_MAKE_MIB_COUNTER(40, 4, etherStatsOctets),
- RTL8365MB_MAKE_MIB_COUNTER(44, 2, etherStatsUnderSizePkts),
- RTL8365MB_MAKE_MIB_COUNTER(46, 2, etherOversizeStats),
- RTL8365MB_MAKE_MIB_COUNTER(48, 2, etherStatsPkts64Octets),
- RTL8365MB_MAKE_MIB_COUNTER(50, 2, etherStatsPkts65to127Octets),
- RTL8365MB_MAKE_MIB_COUNTER(52, 2, etherStatsPkts128to255Octets),
- RTL8365MB_MAKE_MIB_COUNTER(54, 2, etherStatsPkts256to511Octets),
- RTL8365MB_MAKE_MIB_COUNTER(56, 2, etherStatsPkts512to1023Octets),
- RTL8365MB_MAKE_MIB_COUNTER(58, 2, etherStatsPkts1024to1518Octets),
- RTL8365MB_MAKE_MIB_COUNTER(60, 4, ifOutOctets),
- RTL8365MB_MAKE_MIB_COUNTER(64, 2, dot3StatsSingleCollisionFrames),
- RTL8365MB_MAKE_MIB_COUNTER(66, 2, dot3StatsMultipleCollisionFrames),
- RTL8365MB_MAKE_MIB_COUNTER(68, 2, dot3StatsDeferredTransmissions),
- RTL8365MB_MAKE_MIB_COUNTER(70, 2, dot3StatsLateCollisions),
- RTL8365MB_MAKE_MIB_COUNTER(72, 2, etherStatsCollisions),
- RTL8365MB_MAKE_MIB_COUNTER(74, 2, dot3StatsExcessiveCollisions),
- RTL8365MB_MAKE_MIB_COUNTER(76, 2, dot3OutPauseFrames),
- RTL8365MB_MAKE_MIB_COUNTER(78, 2, ifOutDiscards),
- RTL8365MB_MAKE_MIB_COUNTER(80, 2, dot1dTpPortInDiscards),
- RTL8365MB_MAKE_MIB_COUNTER(82, 2, ifOutUcastPkts),
- RTL8365MB_MAKE_MIB_COUNTER(84, 2, ifOutMulticastPkts),
- RTL8365MB_MAKE_MIB_COUNTER(86, 2, ifOutBroadcastPkts),
- RTL8365MB_MAKE_MIB_COUNTER(88, 2, outOampduPkts),
- RTL8365MB_MAKE_MIB_COUNTER(90, 2, inOampduPkts),
- RTL8365MB_MAKE_MIB_COUNTER(92, 4, inIgmpJoinsSuccess),
- RTL8365MB_MAKE_MIB_COUNTER(96, 2, inIgmpJoinsFail),
- RTL8365MB_MAKE_MIB_COUNTER(98, 2, inMldJoinsSuccess),
- RTL8365MB_MAKE_MIB_COUNTER(100, 2, inMldJoinsFail),
- RTL8365MB_MAKE_MIB_COUNTER(102, 2, inReportSuppressionDrop),
- RTL8365MB_MAKE_MIB_COUNTER(104, 2, inLeaveSuppressionDrop),
- RTL8365MB_MAKE_MIB_COUNTER(106, 2, outIgmpReports),
- RTL8365MB_MAKE_MIB_COUNTER(108, 2, outIgmpLeaves),
- RTL8365MB_MAKE_MIB_COUNTER(110, 2, outIgmpGeneralQuery),
- RTL8365MB_MAKE_MIB_COUNTER(112, 2, outIgmpSpecificQuery),
- RTL8365MB_MAKE_MIB_COUNTER(114, 2, outMldReports),
- RTL8365MB_MAKE_MIB_COUNTER(116, 2, outMldLeaves),
- RTL8365MB_MAKE_MIB_COUNTER(118, 2, outMldGeneralQuery),
- RTL8365MB_MAKE_MIB_COUNTER(120, 2, outMldSpecificQuery),
- RTL8365MB_MAKE_MIB_COUNTER(122, 2, inKnownMulticastPkts),
+#define RTL8367C_MAKE_MIB_COUNTER(_offset, _length, _name) \
+ [RTL8367C_MIB_ ## _name] = { _offset, _length, #_name }
+
+static struct rtl8367c_mib_counter rtl8367c_mib_counters[] = {
+ RTL8367C_MAKE_MIB_COUNTER(0, 4, ifInOctets),
+ RTL8367C_MAKE_MIB_COUNTER(4, 2, dot3StatsFCSErrors),
+ RTL8367C_MAKE_MIB_COUNTER(6, 2, dot3StatsSymbolErrors),
+ RTL8367C_MAKE_MIB_COUNTER(8, 2, dot3InPauseFrames),
+ RTL8367C_MAKE_MIB_COUNTER(10, 2, dot3ControlInUnknownOpcodes),
+ RTL8367C_MAKE_MIB_COUNTER(12, 2, etherStatsFragments),
+ RTL8367C_MAKE_MIB_COUNTER(14, 2, etherStatsJabbers),
+ RTL8367C_MAKE_MIB_COUNTER(16, 2, ifInUcastPkts),
+ RTL8367C_MAKE_MIB_COUNTER(18, 2, etherStatsDropEvents),
+ RTL8367C_MAKE_MIB_COUNTER(20, 2, ifInMulticastPkts),
+ RTL8367C_MAKE_MIB_COUNTER(22, 2, ifInBroadcastPkts),
+ RTL8367C_MAKE_MIB_COUNTER(24, 2, inMldChecksumError),
+ RTL8367C_MAKE_MIB_COUNTER(26, 2, inIgmpChecksumError),
+ RTL8367C_MAKE_MIB_COUNTER(28, 2, inMldSpecificQuery),
+ RTL8367C_MAKE_MIB_COUNTER(30, 2, inMldGeneralQuery),
+ RTL8367C_MAKE_MIB_COUNTER(32, 2, inIgmpSpecificQuery),
+ RTL8367C_MAKE_MIB_COUNTER(34, 2, inIgmpGeneralQuery),
+ RTL8367C_MAKE_MIB_COUNTER(36, 2, inMldLeaves),
+ RTL8367C_MAKE_MIB_COUNTER(38, 2, inIgmpLeaves),
+ RTL8367C_MAKE_MIB_COUNTER(40, 4, etherStatsOctets),
+ RTL8367C_MAKE_MIB_COUNTER(44, 2, etherStatsUnderSizePkts),
+ RTL8367C_MAKE_MIB_COUNTER(46, 2, etherOversizeStats),
+ RTL8367C_MAKE_MIB_COUNTER(48, 2, etherStatsPkts64Octets),
+ RTL8367C_MAKE_MIB_COUNTER(50, 2, etherStatsPkts65to127Octets),
+ RTL8367C_MAKE_MIB_COUNTER(52, 2, etherStatsPkts128to255Octets),
+ RTL8367C_MAKE_MIB_COUNTER(54, 2, etherStatsPkts256to511Octets),
+ RTL8367C_MAKE_MIB_COUNTER(56, 2, etherStatsPkts512to1023Octets),
+ RTL8367C_MAKE_MIB_COUNTER(58, 2, etherStatsPkts1024to1518Octets),
+ RTL8367C_MAKE_MIB_COUNTER(60, 4, ifOutOctets),
+ RTL8367C_MAKE_MIB_COUNTER(64, 2, dot3StatsSingleCollisionFrames),
+ RTL8367C_MAKE_MIB_COUNTER(66, 2, dot3StatsMultipleCollisionFrames),
+ RTL8367C_MAKE_MIB_COUNTER(68, 2, dot3StatsDeferredTransmissions),
+ RTL8367C_MAKE_MIB_COUNTER(70, 2, dot3StatsLateCollisions),
+ RTL8367C_MAKE_MIB_COUNTER(72, 2, etherStatsCollisions),
+ RTL8367C_MAKE_MIB_COUNTER(74, 2, dot3StatsExcessiveCollisions),
+ RTL8367C_MAKE_MIB_COUNTER(76, 2, dot3OutPauseFrames),
+ RTL8367C_MAKE_MIB_COUNTER(78, 2, ifOutDiscards),
+ RTL8367C_MAKE_MIB_COUNTER(80, 2, dot1dTpPortInDiscards),
+ RTL8367C_MAKE_MIB_COUNTER(82, 2, ifOutUcastPkts),
+ RTL8367C_MAKE_MIB_COUNTER(84, 2, ifOutMulticastPkts),
+ RTL8367C_MAKE_MIB_COUNTER(86, 2, ifOutBroadcastPkts),
+ RTL8367C_MAKE_MIB_COUNTER(88, 2, outOampduPkts),
+ RTL8367C_MAKE_MIB_COUNTER(90, 2, inOampduPkts),
+ RTL8367C_MAKE_MIB_COUNTER(92, 4, inIgmpJoinsSuccess),
+ RTL8367C_MAKE_MIB_COUNTER(96, 2, inIgmpJoinsFail),
+ RTL8367C_MAKE_MIB_COUNTER(98, 2, inMldJoinsSuccess),
+ RTL8367C_MAKE_MIB_COUNTER(100, 2, inMldJoinsFail),
+ RTL8367C_MAKE_MIB_COUNTER(102, 2, inReportSuppressionDrop),
+ RTL8367C_MAKE_MIB_COUNTER(104, 2, inLeaveSuppressionDrop),
+ RTL8367C_MAKE_MIB_COUNTER(106, 2, outIgmpReports),
+ RTL8367C_MAKE_MIB_COUNTER(108, 2, outIgmpLeaves),
+ RTL8367C_MAKE_MIB_COUNTER(110, 2, outIgmpGeneralQuery),
+ RTL8367C_MAKE_MIB_COUNTER(112, 2, outIgmpSpecificQuery),
+ RTL8367C_MAKE_MIB_COUNTER(114, 2, outMldReports),
+ RTL8367C_MAKE_MIB_COUNTER(116, 2, outMldLeaves),
+ RTL8367C_MAKE_MIB_COUNTER(118, 2, outMldGeneralQuery),
+ RTL8367C_MAKE_MIB_COUNTER(120, 2, outMldSpecificQuery),
+ RTL8367C_MAKE_MIB_COUNTER(122, 2, inKnownMulticastPkts),
};
-static_assert(ARRAY_SIZE(rtl8365mb_mib_counters) == RTL8365MB_MIB_END);
+static_assert(ARRAY_SIZE(rtl8367c_mib_counters) == RTL8367C_MIB_END);
-struct rtl8365mb_jam_tbl_entry {
+struct rtl8367c_jam_tbl_entry {
u16 reg;
u16 val;
};
/* Lifted from the vendor driver sources */
-static const struct rtl8365mb_jam_tbl_entry rtl8365mb_init_jam_8365mb_vc[] = {
+static const struct rtl8367c_jam_tbl_entry rtl8367c_init_jam_8367c[] = {
{ 0x13EB, 0x15BB }, { 0x1303, 0x06D6 }, { 0x1304, 0x0700 },
{ 0x13E2, 0x003F }, { 0x13F9, 0x0090 }, { 0x121E, 0x03CA },
{ 0x1233, 0x0352 }, { 0x1237, 0x00A0 }, { 0x123A, 0x0030 },
@@ -456,43 +445,43 @@ static const struct rtl8365mb_jam_tbl_entry rtl8365mb_init_jam_8365mb_vc[] = {
{ 0x13F0, 0x0000 },
};
-static const struct rtl8365mb_jam_tbl_entry rtl8365mb_init_jam_common[] = {
+static const struct rtl8367c_jam_tbl_entry rtl8367c_init_jam_common[] = {
{ 0x1200, 0x7FCB }, { 0x0884, 0x0003 }, { 0x06EB, 0x0001 },
{ 0x03Fa, 0x0007 }, { 0x08C8, 0x00C0 }, { 0x0A30, 0x020E },
{ 0x0800, 0x0000 }, { 0x0802, 0x0000 }, { 0x09DA, 0x0013 },
{ 0x1D32, 0x0002 },
};
-enum rtl8365mb_stp_state {
- RTL8365MB_STP_STATE_DISABLED = 0,
- RTL8365MB_STP_STATE_BLOCKING = 1,
- RTL8365MB_STP_STATE_LEARNING = 2,
- RTL8365MB_STP_STATE_FORWARDING = 3,
+enum rtl8367c_stp_state {
+ RTL8367C_STP_STATE_DISABLED = 0,
+ RTL8367C_STP_STATE_BLOCKING = 1,
+ RTL8367C_STP_STATE_LEARNING = 2,
+ RTL8367C_STP_STATE_FORWARDING = 3,
};
-enum rtl8365mb_cpu_insert {
- RTL8365MB_CPU_INSERT_TO_ALL = 0,
- RTL8365MB_CPU_INSERT_TO_TRAPPING = 1,
- RTL8365MB_CPU_INSERT_TO_NONE = 2,
+enum rtl8367c_cpu_insert {
+ RTL8367C_CPU_INSERT_TO_ALL = 0,
+ RTL8367C_CPU_INSERT_TO_TRAPPING = 1,
+ RTL8367C_CPU_INSERT_TO_NONE = 2,
};
-enum rtl8365mb_cpu_position {
- RTL8365MB_CPU_POS_AFTER_SA = 0,
- RTL8365MB_CPU_POS_BEFORE_CRC = 1,
+enum rtl8367c_cpu_position {
+ RTL8367C_CPU_POS_AFTER_SA = 0,
+ RTL8367C_CPU_POS_BEFORE_CRC = 1,
};
-enum rtl8365mb_cpu_format {
- RTL8365MB_CPU_FORMAT_8BYTES = 0,
- RTL8365MB_CPU_FORMAT_4BYTES = 1,
+enum rtl8367c_cpu_format {
+ RTL8367C_CPU_FORMAT_8BYTES = 0,
+ RTL8367C_CPU_FORMAT_4BYTES = 1,
};
-enum rtl8365mb_cpu_rxlen {
- RTL8365MB_CPU_RXLEN_72BYTES = 0,
- RTL8365MB_CPU_RXLEN_64BYTES = 1,
+enum rtl8367c_cpu_rxlen {
+ RTL8367C_CPU_RXLEN_72BYTES = 0,
+ RTL8367C_CPU_RXLEN_64BYTES = 1,
};
/**
- * struct rtl8365mb_cpu - CPU port configuration
+ * struct rtl8367c_cpu - CPU port configuration
* @enable: enable/disable hardware insertion of CPU tag in switch->CPU frames
* @mask: port mask of ports that parse should parse CPU tags
* @trap_port: forward trapped frames to this port
@@ -504,26 +493,26 @@ enum rtl8365mb_cpu_rxlen {
* Represents the CPU tagging and CPU port configuration of the switch. These
* settings are configurable at runtime.
*/
-struct rtl8365mb_cpu {
+struct rtl8367c_cpu {
bool enable;
u32 mask;
u32 trap_port;
- enum rtl8365mb_cpu_insert insert;
- enum rtl8365mb_cpu_position position;
- enum rtl8365mb_cpu_rxlen rx_length;
- enum rtl8365mb_cpu_format format;
+ enum rtl8367c_cpu_insert insert;
+ enum rtl8367c_cpu_position position;
+ enum rtl8367c_cpu_rxlen rx_length;
+ enum rtl8367c_cpu_format format;
};
/**
- * struct rtl8365mb_port - private per-port data
+ * struct rtl8367c_port - private per-port data
* @priv: pointer to parent realtek_priv data
* @index: DSA port index, same as dsa_port::index
- * @stats: link statistics populated by rtl8365mb_stats_poll, ready for atomic
- * access via rtl8365mb_get_stats64
+ * @stats: link statistics populated by rtl8367c_stats_poll, ready for atomic
+ * access via rtl8367c_get_stats64
* @stats_lock: protect the stats structure during read/update
* @mib_work: delayed work for polling MIB counters
*/
-struct rtl8365mb_port {
+struct rtl8367c_port {
struct realtek_priv *priv;
unsigned int index;
struct rtnl_link_stats64 stats;
@@ -532,7 +521,7 @@ struct rtl8365mb_port {
};
/**
- * struct rtl8365mb - private chip-specific driver data
+ * struct rtl8367c - private chip-specific driver data
* @priv: pointer to parent realtek_priv data
* @irq: registered IRQ or zero
* @chip_id: chip identifier
@@ -547,52 +536,52 @@ struct rtl8365mb_port {
*
* Private data for this driver.
*/
-struct rtl8365mb {
+struct rtl8367c {
struct realtek_priv *priv;
int irq;
u32 chip_id;
u32 chip_ver;
u32 port_mask;
u32 learn_limit_max;
- struct rtl8365mb_cpu cpu;
+ struct rtl8367c_cpu cpu;
struct mutex mib_lock;
- struct rtl8365mb_port ports[RTL8365MB_MAX_NUM_PORTS];
- const struct rtl8365mb_jam_tbl_entry *jam_table;
+ struct rtl8367c_port ports[RTL8367C_MAX_NUM_PORTS];
+ const struct rtl8367c_jam_tbl_entry *jam_table;
size_t jam_size;
};
-static int rtl8365mb_phy_poll_busy(struct realtek_priv *priv)
+static int rtl8367c_phy_poll_busy(struct realtek_priv *priv)
{
u32 val;
return regmap_read_poll_timeout(priv->map,
- RTL8365MB_INDIRECT_ACCESS_STATUS_REG,
+ RTL8367C_INDIRECT_ACCESS_STATUS_REG,
val, !val, 10, 100);
}
-static int rtl8365mb_phy_ocp_prepare(struct realtek_priv *priv, int phy,
+static int rtl8367c_phy_ocp_prepare(struct realtek_priv *priv, int phy,
u32 ocp_addr)
{
u32 val;
int ret;
/* Set OCP prefix */
- val = FIELD_GET(RTL8365MB_PHY_OCP_ADDR_PREFIX_MASK, ocp_addr);
+ val = FIELD_GET(RTL8367C_PHY_OCP_ADDR_PREFIX_MASK, ocp_addr);
ret = regmap_update_bits(
- priv->map, RTL8365MB_GPHY_OCP_MSB_0_REG,
- RTL8365MB_GPHY_OCP_MSB_0_CFG_CPU_OCPADR_MASK,
- FIELD_PREP(RTL8365MB_GPHY_OCP_MSB_0_CFG_CPU_OCPADR_MASK, val));
+ priv->map, RTL8367C_GPHY_OCP_MSB_0_REG,
+ RTL8367C_GPHY_OCP_MSB_0_CFG_CPU_OCPADR_MASK,
+ FIELD_PREP(RTL8367C_GPHY_OCP_MSB_0_CFG_CPU_OCPADR_MASK, val));
if (ret)
return ret;
/* Set PHY register address */
- val = RTL8365MB_PHY_BASE;
- val |= FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_ADDRESS_PHYNUM_MASK, phy);
- val |= FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_5_1_MASK,
+ val = RTL8367C_PHY_BASE;
+ val |= FIELD_PREP(RTL8367C_INDIRECT_ACCESS_ADDRESS_PHYNUM_MASK, phy);
+ val |= FIELD_PREP(RTL8367C_INDIRECT_ACCESS_ADDRESS_OCPADR_5_1_MASK,
ocp_addr >> 1);
- val |= FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_9_6_MASK,
+ val |= FIELD_PREP(RTL8367C_INDIRECT_ACCESS_ADDRESS_OCPADR_9_6_MASK,
ocp_addr >> 6);
- ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_ADDRESS_REG,
+ ret = regmap_write(priv->map, RTL8367C_INDIRECT_ACCESS_ADDRESS_REG,
val);
if (ret)
return ret;
@@ -600,35 +589,35 @@ static int rtl8365mb_phy_ocp_prepare(struct realtek_priv *priv, int phy,
return 0;
}
-static int rtl8365mb_phy_ocp_read(struct realtek_priv *priv, int phy,
+static int rtl8367c_phy_ocp_read(struct realtek_priv *priv, int phy,
u32 ocp_addr, u16 *data)
{
u32 val;
int ret;
- ret = rtl8365mb_phy_poll_busy(priv);
+ ret = rtl8367c_phy_poll_busy(priv);
if (ret)
return ret;
- ret = rtl8365mb_phy_ocp_prepare(priv, phy, ocp_addr);
+ ret = rtl8367c_phy_ocp_prepare(priv, phy, ocp_addr);
if (ret)
return ret;
/* Execute read operation */
- val = FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_MASK,
- RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_VALUE) |
- FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_CTRL_RW_MASK,
- RTL8365MB_INDIRECT_ACCESS_CTRL_RW_READ);
- ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_CTRL_REG, val);
+ val = FIELD_PREP(RTL8367C_INDIRECT_ACCESS_CTRL_CMD_MASK,
+ RTL8367C_INDIRECT_ACCESS_CTRL_CMD_VALUE) |
+ FIELD_PREP(RTL8367C_INDIRECT_ACCESS_CTRL_RW_MASK,
+ RTL8367C_INDIRECT_ACCESS_CTRL_RW_READ);
+ ret = regmap_write(priv->map, RTL8367C_INDIRECT_ACCESS_CTRL_REG, val);
if (ret)
return ret;
- ret = rtl8365mb_phy_poll_busy(priv);
+ ret = rtl8367c_phy_poll_busy(priv);
if (ret)
return ret;
/* Get PHY register data */
- ret = regmap_read(priv->map, RTL8365MB_INDIRECT_ACCESS_READ_DATA_REG,
+ ret = regmap_read(priv->map, RTL8367C_INDIRECT_ACCESS_READ_DATA_REG,
&val);
if (ret)
return ret;
@@ -638,58 +627,58 @@ static int rtl8365mb_phy_ocp_read(struct realtek_priv *priv, int phy,
return 0;
}
-static int rtl8365mb_phy_ocp_write(struct realtek_priv *priv, int phy,
+static int rtl8367c_phy_ocp_write(struct realtek_priv *priv, int phy,
u32 ocp_addr, u16 data)
{
u32 val;
int ret;
- ret = rtl8365mb_phy_poll_busy(priv);
+ ret = rtl8367c_phy_poll_busy(priv);
if (ret)
return ret;
- ret = rtl8365mb_phy_ocp_prepare(priv, phy, ocp_addr);
+ ret = rtl8367c_phy_ocp_prepare(priv, phy, ocp_addr);
if (ret)
return ret;
/* Set PHY register data */
- ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_WRITE_DATA_REG,
+ ret = regmap_write(priv->map, RTL8367C_INDIRECT_ACCESS_WRITE_DATA_REG,
data);
if (ret)
return ret;
/* Execute write operation */
- val = FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_MASK,
- RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_VALUE) |
- FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_CTRL_RW_MASK,
- RTL8365MB_INDIRECT_ACCESS_CTRL_RW_WRITE);
- ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_CTRL_REG, val);
+ val = FIELD_PREP(RTL8367C_INDIRECT_ACCESS_CTRL_CMD_MASK,
+ RTL8367C_INDIRECT_ACCESS_CTRL_CMD_VALUE) |
+ FIELD_PREP(RTL8367C_INDIRECT_ACCESS_CTRL_RW_MASK,
+ RTL8367C_INDIRECT_ACCESS_CTRL_RW_WRITE);
+ ret = regmap_write(priv->map, RTL8367C_INDIRECT_ACCESS_CTRL_REG, val);
if (ret)
return ret;
- ret = rtl8365mb_phy_poll_busy(priv);
+ ret = rtl8367c_phy_poll_busy(priv);
if (ret)
return ret;
return 0;
}
-static int rtl8365mb_phy_read(struct dsa_switch *ds, int phy, int regnum)
+static int rtl8367c_phy_read(struct dsa_switch *ds, int phy, int regnum)
{
u32 ocp_addr;
u16 val;
int ret;
struct realtek_priv *priv = ds->priv;
- if (phy > RTL8365MB_PHYADDRMAX)
+ if (phy > RTL8367C_PHYADDRMAX)
return -EINVAL;
- if (regnum > RTL8365MB_PHYREGMAX)
+ if (regnum > RTL8367C_PHYREGMAX)
return -EINVAL;
- ocp_addr = RTL8365MB_PHY_OCP_ADDR_PHYREG_BASE + regnum * 2;
+ ocp_addr = RTL8367C_PHY_OCP_ADDR_PHYREG_BASE + regnum * 2;
- ret = rtl8365mb_phy_ocp_read(priv, phy, ocp_addr, &val);
+ ret = rtl8367c_phy_ocp_read(priv, phy, ocp_addr, &val);
if (ret) {
dev_err(priv->dev,
"failed to read PHY%d reg %02x @ %04x, ret %d\n", phy,
@@ -703,22 +692,22 @@ static int rtl8365mb_phy_read(struct dsa_switch *ds, int phy, int regnum)
return val;
}
-static int rtl8365mb_phy_write(struct dsa_switch *ds, int phy, int regnum,
+static int rtl8367c_phy_write(struct dsa_switch *ds, int phy, int regnum,
u16 val)
{
u32 ocp_addr;
int ret;
struct realtek_priv *priv = (struct realtek_priv *)ds->priv;
- if (phy > RTL8365MB_PHYADDRMAX)
+ if (phy > RTL8367C_PHYADDRMAX)
return -EINVAL;
- if (regnum > RTL8365MB_PHYREGMAX)
+ if (regnum > RTL8367C_PHYREGMAX)
return -EINVAL;
- ocp_addr = RTL8365MB_PHY_OCP_ADDR_PHYREG_BASE + regnum * 2;
+ ocp_addr = RTL8367C_PHY_OCP_ADDR_PHYREG_BASE + regnum * 2;
- ret = rtl8365mb_phy_ocp_write(priv, phy, ocp_addr, val);
+ ret = rtl8367c_phy_ocp_write(priv, phy, ocp_addr, val);
if (ret) {
dev_err(priv->dev,
"failed to write PHY%d reg %02x @ %04x, ret %d\n", phy,
@@ -733,13 +722,13 @@ static int rtl8365mb_phy_write(struct dsa_switch *ds, int phy, int regnum,
}
static enum dsa_tag_protocol
-rtl8365mb_get_tag_protocol(struct dsa_switch *ds, int port,
+rtl8367c_get_tag_protocol(struct dsa_switch *ds, int port,
enum dsa_tag_protocol mp)
{
return DSA_TAG_PROTO_RTL8_4;
}
-static int rtl8365mb_ext_config_rgmii(struct realtek_priv *priv, int port,
+static int rtl8367c_ext_config_rgmii(struct realtek_priv *priv, int port,
phy_interface_t interface)
{
struct device_node *dn;
@@ -774,7 +763,7 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_priv *priv, int port,
*
* The vendor driver also states that this must be configured *before*
* forcing the external interface into a particular mode, which is done
- * in the rtl8365mb_phylink_mac_link_{up,down} functions.
+ * in the rtl8367c_phylink_mac_link_{up,down} functions.
*
* Only configure an RGMII TX (resp. RX) delay if the
* tx-internal-delay-ps (resp. rx-internal-delay-ps) OF property is
@@ -803,19 +792,19 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_priv *priv, int port,
}
ret = regmap_update_bits(
- priv->map, RTL8365MB_EXT_RGMXF_REG(ext_port),
- RTL8365MB_EXT_RGMXF_TXDELAY_MASK |
- RTL8365MB_EXT_RGMXF_RXDELAY_MASK,
- FIELD_PREP(RTL8365MB_EXT_RGMXF_TXDELAY_MASK, tx_delay) |
- FIELD_PREP(RTL8365MB_EXT_RGMXF_RXDELAY_MASK, rx_delay));
+ priv->map, RTL8367C_EXT_RGMXF_REG(ext_port),
+ RTL8367C_EXT_RGMXF_TXDELAY_MASK |
+ RTL8367C_EXT_RGMXF_RXDELAY_MASK,
+ FIELD_PREP(RTL8367C_EXT_RGMXF_TXDELAY_MASK, tx_delay) |
+ FIELD_PREP(RTL8367C_EXT_RGMXF_RXDELAY_MASK, rx_delay));
if (ret)
return ret;
ret = regmap_update_bits(
- priv->map, RTL8365MB_DIGITAL_INTERFACE_SELECT_REG(ext_port),
- RTL8365MB_DIGITAL_INTERFACE_SELECT_MODE_MASK(ext_port),
- RTL8365MB_EXT_PORT_MODE_RGMII
- << RTL8365MB_DIGITAL_INTERFACE_SELECT_MODE_OFFSET(
+ priv->map, RTL8367C_DIGITAL_INTERFACE_SELECT_REG(ext_port),
+ RTL8367C_DIGITAL_INTERFACE_SELECT_MODE_MASK(ext_port),
+ RTL8367C_EXT_PORT_MODE_RGMII
+ << RTL8367C_DIGITAL_INTERFACE_SELECT_MODE_OFFSET(
ext_port));
if (ret)
return ret;
@@ -823,7 +812,7 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_priv *priv, int port,
return 0;
}
-static int rtl8365mb_ext_config_forcemode(struct realtek_priv *priv, int port,
+static int rtl8367c_ext_config_forcemode(struct realtek_priv *priv, int port,
bool link, int speed, int duplex,
bool tx_pause, bool rx_pause)
{
@@ -850,11 +839,11 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_priv *priv, int port,
r_tx_pause = tx_pause ? 1 : 0;
if (speed == SPEED_1000) {
- r_speed = RTL8365MB_PORT_SPEED_1000M;
+ r_speed = RTL8367C_PORT_SPEED_1000M;
} else if (speed == SPEED_100) {
- r_speed = RTL8365MB_PORT_SPEED_100M;
+ r_speed = RTL8367C_PORT_SPEED_100M;
} else if (speed == SPEED_10) {
- r_speed = RTL8365MB_PORT_SPEED_10M;
+ r_speed = RTL8367C_PORT_SPEED_10M;
} else {
dev_err(priv->dev, "unsupported port speed %s\n",
phy_speed_to_str(speed));
@@ -879,17 +868,17 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_priv *priv, int port,
r_duplex = 0;
}
- val = FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_EN_MASK, 1) |
- FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_TXPAUSE_MASK,
+ val = FIELD_PREP(RTL8367C_DIGITAL_INTERFACE_FORCE_EN_MASK, 1) |
+ FIELD_PREP(RTL8367C_DIGITAL_INTERFACE_FORCE_TXPAUSE_MASK,
r_tx_pause) |
- FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_RXPAUSE_MASK,
+ FIELD_PREP(RTL8367C_DIGITAL_INTERFACE_FORCE_RXPAUSE_MASK,
r_rx_pause) |
- FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_LINK_MASK, r_link) |
- FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_DUPLEX_MASK,
+ FIELD_PREP(RTL8367C_DIGITAL_INTERFACE_FORCE_LINK_MASK, r_link) |
+ FIELD_PREP(RTL8367C_DIGITAL_INTERFACE_FORCE_DUPLEX_MASK,
r_duplex) |
- FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_SPEED_MASK, r_speed);
+ FIELD_PREP(RTL8367C_DIGITAL_INTERFACE_FORCE_SPEED_MASK, r_speed);
ret = regmap_write(priv->map,
- RTL8365MB_DIGITAL_INTERFACE_FORCE_REG(ext_port),
+ RTL8367C_DIGITAL_INTERFACE_FORCE_REG(ext_port),
val);
if (ret)
return ret;
@@ -897,7 +886,7 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_priv *priv, int port,
return 0;
}
-static bool rtl8365mb_phy_mode_supported(struct dsa_switch *ds, int port,
+static bool rtl8367c_phy_mode_supported(struct dsa_switch *ds, int port,
phy_interface_t interface)
{
if (dsa_is_user_port(ds, port) &&
@@ -914,7 +903,7 @@ static bool rtl8365mb_phy_mode_supported(struct dsa_switch *ds, int port,
return false;
}
-static void rtl8365mb_phylink_validate(struct dsa_switch *ds, int port,
+static void rtl8367c_phylink_validate(struct dsa_switch *ds, int port,
unsigned long *supported,
struct phylink_link_state *state)
{
@@ -926,7 +915,7 @@ static void rtl8365mb_phylink_validate(struct dsa_switch *ds, int port,
* expects the MAC driver to return all supported link modes.
*/
if (state->interface != PHY_INTERFACE_MODE_NA &&
- !rtl8365mb_phy_mode_supported(ds, port, state->interface)) {
+ !rtl8367c_phy_mode_supported(ds, port, state->interface)) {
dev_err(priv->dev, "phy mode %s is unsupported on port %d\n",
phy_modes(state->interface), port);
linkmode_zero(supported);
@@ -949,14 +938,14 @@ static void rtl8365mb_phylink_validate(struct dsa_switch *ds, int port,
linkmode_and(state->advertising, state->advertising, mask);
}
-static void rtl8365mb_phylink_mac_config(struct dsa_switch *ds, int port,
+static void rtl8367c_phylink_mac_config(struct dsa_switch *ds, int port,
unsigned int mode,
const struct phylink_link_state *state)
{
struct realtek_priv *priv = ds->priv;
int ret;
- if (!rtl8365mb_phy_mode_supported(ds, port, state->interface)) {
+ if (!rtl8367c_phy_mode_supported(ds, port, state->interface)) {
dev_err(priv->dev, "phy mode %s is unsupported on port %d\n",
phy_modes(state->interface), port);
return;
@@ -970,7 +959,7 @@ static void rtl8365mb_phylink_mac_config(struct dsa_switch *ds, int port,
}
if (phy_interface_mode_is_rgmii(state->interface)) {
- ret = rtl8365mb_ext_config_rgmii(priv, port, state->interface);
+ ret = rtl8367c_ext_config_rgmii(priv, port, state->interface);
if (ret)
dev_err(priv->dev,
"failed to configure RGMII mode on port %d: %d\n",
@@ -983,13 +972,13 @@ static void rtl8365mb_phylink_mac_config(struct dsa_switch *ds, int port,
*/
}
-static void rtl8365mb_phylink_mac_link_down(struct dsa_switch *ds, int port,
+static void rtl8367c_phylink_mac_link_down(struct dsa_switch *ds, int port,
unsigned int mode,
phy_interface_t interface)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb_port *p;
- struct rtl8365mb *mb;
+ struct rtl8367c_port *p;
+ struct rtl8367c *mb;
int ret;
mb = priv->chip_data;
@@ -997,7 +986,7 @@ static void rtl8365mb_phylink_mac_link_down(struct dsa_switch *ds, int port,
cancel_delayed_work_sync(&p->mib_work);
if (phy_interface_mode_is_rgmii(interface)) {
- ret = rtl8365mb_ext_config_forcemode(priv, port, false, 0, 0,
+ ret = rtl8367c_ext_config_forcemode(priv, port, false, 0, 0,
false, false);
if (ret)
dev_err(priv->dev,
@@ -1008,7 +997,7 @@ static void rtl8365mb_phylink_mac_link_down(struct dsa_switch *ds, int port,
}
}
-static void rtl8365mb_phylink_mac_link_up(struct dsa_switch *ds, int port,
+static void rtl8367c_phylink_mac_link_up(struct dsa_switch *ds, int port,
unsigned int mode,
phy_interface_t interface,
struct phy_device *phydev, int speed,
@@ -1016,8 +1005,8 @@ static void rtl8365mb_phylink_mac_link_up(struct dsa_switch *ds, int port,
bool rx_pause)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb_port *p;
- struct rtl8365mb *mb;
+ struct rtl8367c_port *p;
+ struct rtl8367c *mb;
int ret;
mb = priv->chip_data;
@@ -1025,7 +1014,7 @@ static void rtl8365mb_phylink_mac_link_up(struct dsa_switch *ds, int port,
schedule_delayed_work(&p->mib_work, 0);
if (phy_interface_mode_is_rgmii(interface)) {
- ret = rtl8365mb_ext_config_forcemode(priv, port, true, speed,
+ ret = rtl8367c_ext_config_forcemode(priv, port, true, speed,
duplex, tx_pause,
rx_pause);
if (ret)
@@ -1037,58 +1026,58 @@ static void rtl8365mb_phylink_mac_link_up(struct dsa_switch *ds, int port,
}
}
-static void rtl8365mb_port_stp_state_set(struct dsa_switch *ds, int port,
+static void rtl8367c_port_stp_state_set(struct dsa_switch *ds, int port,
u8 state)
{
struct realtek_priv *priv = ds->priv;
- enum rtl8365mb_stp_state val;
+ enum rtl8367c_stp_state val;
int msti = 0;
switch (state) {
case BR_STATE_DISABLED:
- val = RTL8365MB_STP_STATE_DISABLED;
+ val = RTL8367C_STP_STATE_DISABLED;
break;
case BR_STATE_BLOCKING:
case BR_STATE_LISTENING:
- val = RTL8365MB_STP_STATE_BLOCKING;
+ val = RTL8367C_STP_STATE_BLOCKING;
break;
case BR_STATE_LEARNING:
- val = RTL8365MB_STP_STATE_LEARNING;
+ val = RTL8367C_STP_STATE_LEARNING;
break;
case BR_STATE_FORWARDING:
- val = RTL8365MB_STP_STATE_FORWARDING;
+ val = RTL8367C_STP_STATE_FORWARDING;
break;
default:
dev_err(priv->dev, "invalid STP state: %u\n", state);
return;
}
- regmap_update_bits(priv->map, RTL8365MB_MSTI_CTRL_REG(msti, port),
- RTL8365MB_MSTI_CTRL_PORT_STATE_MASK(port),
- val << RTL8365MB_MSTI_CTRL_PORT_STATE_OFFSET(port));
+ regmap_update_bits(priv->map, RTL8367C_MSTI_CTRL_REG(msti, port),
+ RTL8367C_MSTI_CTRL_PORT_STATE_MASK(port),
+ val << RTL8367C_MSTI_CTRL_PORT_STATE_OFFSET(port));
}
-static int rtl8365mb_port_set_learning(struct realtek_priv *priv, int port,
+static int rtl8367c_port_set_learning(struct realtek_priv *priv, int port,
bool enable)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
/* Enable/disable learning by limiting the number of L2 addresses the
* port can learn. Realtek documentation states that a limit of zero
* disables learning. When enabling learning, set it to the chip's
* maximum.
*/
- return regmap_write(priv->map, RTL8365MB_LUT_PORT_LEARN_LIMIT_REG(port),
+ return regmap_write(priv->map, RTL8367C_LUT_PORT_LEARN_LIMIT_REG(port),
enable ? mb->learn_limit_max : 0);
}
-static int rtl8365mb_port_set_isolation(struct realtek_priv *priv, int port,
+static int rtl8367c_port_set_isolation(struct realtek_priv *priv, int port,
u32 mask)
{
- return regmap_write(priv->map, RTL8365MB_PORT_ISOLATION_REG(port), mask);
+ return regmap_write(priv->map, RTL8367C_PORT_ISOLATION_REG(port), mask);
}
-static int rtl8365mb_mib_counter_read(struct realtek_priv *priv, int port,
+static int rtl8367c_mib_counter_read(struct realtek_priv *priv, int port,
u32 offset, u32 length, u64 *mibvalue)
{
u64 tmpvalue = 0;
@@ -1100,20 +1089,20 @@ static int rtl8365mb_mib_counter_read(struct realtek_priv *priv, int port,
* and then poll the control register before reading the value from some
* counter registers.
*/
- ret = regmap_write(priv->map, RTL8365MB_MIB_ADDRESS_REG,
- RTL8365MB_MIB_ADDRESS(port, offset));
+ ret = regmap_write(priv->map, RTL8367C_MIB_ADDRESS_REG,
+ RTL8367C_MIB_ADDRESS(port, offset));
if (ret)
return ret;
/* Poll for completion */
- ret = regmap_read_poll_timeout(priv->map, RTL8365MB_MIB_CTRL0_REG, val,
- !(val & RTL8365MB_MIB_CTRL0_BUSY_MASK),
+ ret = regmap_read_poll_timeout(priv->map, RTL8367C_MIB_CTRL0_REG, val,
+ !(val & RTL8367C_MIB_CTRL0_BUSY_MASK),
10, 100);
if (ret)
return ret;
/* Presumably this indicates a MIB counter read failure */
- if (val & RTL8365MB_MIB_CTRL0_RESET_MASK)
+ if (val & RTL8367C_MIB_CTRL0_RESET_MASK)
return -EIO;
/* There are four MIB counter registers each holding a 16 bit word of a
@@ -1129,7 +1118,7 @@ static int rtl8365mb_mib_counter_read(struct realtek_priv *priv, int port,
/* Read the MIB counter 16 bits at a time */
for (i = 0; i < length; i++) {
ret = regmap_read(priv->map,
- RTL8365MB_MIB_COUNTER_REG(offset - i), &val);
+ RTL8367C_MIB_COUNTER_REG(offset - i), &val);
if (ret)
return ret;
@@ -1142,20 +1131,20 @@ static int rtl8365mb_mib_counter_read(struct realtek_priv *priv, int port,
return 0;
}
-static void rtl8365mb_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *data)
+static void rtl8367c_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *data)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb *mb;
+ struct rtl8367c *mb;
int ret;
int i;
mb = priv->chip_data;
mutex_lock(&mb->mib_lock);
- for (i = 0; i < RTL8365MB_MIB_END; i++) {
- struct rtl8365mb_mib_counter *mib = &rtl8365mb_mib_counters[i];
+ for (i = 0; i < RTL8367C_MIB_END; i++) {
+ struct rtl8367c_mib_counter *mib = &rtl8367c_mib_counters[i];
- ret = rtl8365mb_mib_counter_read(priv, port, mib->offset,
+ ret = rtl8367c_mib_counter_read(priv, port, mib->offset,
mib->length, &data[i]);
if (ret) {
dev_err(priv->dev,
@@ -1167,83 +1156,83 @@ static void rtl8365mb_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *da
mutex_unlock(&mb->mib_lock);
}
-static void rtl8365mb_get_strings(struct dsa_switch *ds, int port, u32 stringset, u8 *data)
+static void rtl8367c_get_strings(struct dsa_switch *ds, int port, u32 stringset, u8 *data)
{
int i;
if (stringset != ETH_SS_STATS)
return;
- for (i = 0; i < RTL8365MB_MIB_END; i++) {
- struct rtl8365mb_mib_counter *mib = &rtl8365mb_mib_counters[i];
+ for (i = 0; i < RTL8367C_MIB_END; i++) {
+ struct rtl8367c_mib_counter *mib = &rtl8367c_mib_counters[i];
strncpy(data + i * ETH_GSTRING_LEN, mib->name, ETH_GSTRING_LEN);
}
}
-static int rtl8365mb_get_sset_count(struct dsa_switch *ds, int port, int sset)
+static int rtl8367c_get_sset_count(struct dsa_switch *ds, int port, int sset)
{
if (sset != ETH_SS_STATS)
return -EOPNOTSUPP;
- return RTL8365MB_MIB_END;
+ return RTL8367C_MIB_END;
}
-static void rtl8365mb_get_phy_stats(struct dsa_switch *ds, int port,
+static void rtl8367c_get_phy_stats(struct dsa_switch *ds, int port,
struct ethtool_eth_phy_stats *phy_stats)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb_mib_counter *mib;
- struct rtl8365mb *mb;
+ struct rtl8367c_mib_counter *mib;
+ struct rtl8367c *mb;
mb = priv->chip_data;
- mib = &rtl8365mb_mib_counters[RTL8365MB_MIB_dot3StatsSymbolErrors];
+ mib = &rtl8367c_mib_counters[RTL8367C_MIB_dot3StatsSymbolErrors];
mutex_lock(&mb->mib_lock);
- rtl8365mb_mib_counter_read(priv, port, mib->offset, mib->length,
+ rtl8367c_mib_counter_read(priv, port, mib->offset, mib->length,
&phy_stats->SymbolErrorDuringCarrier);
mutex_unlock(&mb->mib_lock);
}
-static void rtl8365mb_get_mac_stats(struct dsa_switch *ds, int port,
+static void rtl8367c_get_mac_stats(struct dsa_switch *ds, int port,
struct ethtool_eth_mac_stats *mac_stats)
{
- u64 cnt[RTL8365MB_MIB_END] = {
- [RTL8365MB_MIB_ifOutOctets] = 1,
- [RTL8365MB_MIB_ifOutUcastPkts] = 1,
- [RTL8365MB_MIB_ifOutMulticastPkts] = 1,
- [RTL8365MB_MIB_ifOutBroadcastPkts] = 1,
- [RTL8365MB_MIB_dot3OutPauseFrames] = 1,
- [RTL8365MB_MIB_ifOutDiscards] = 1,
- [RTL8365MB_MIB_ifInOctets] = 1,
- [RTL8365MB_MIB_ifInUcastPkts] = 1,
- [RTL8365MB_MIB_ifInMulticastPkts] = 1,
- [RTL8365MB_MIB_ifInBroadcastPkts] = 1,
- [RTL8365MB_MIB_dot3InPauseFrames] = 1,
- [RTL8365MB_MIB_dot3StatsSingleCollisionFrames] = 1,
- [RTL8365MB_MIB_dot3StatsMultipleCollisionFrames] = 1,
- [RTL8365MB_MIB_dot3StatsFCSErrors] = 1,
- [RTL8365MB_MIB_dot3StatsDeferredTransmissions] = 1,
- [RTL8365MB_MIB_dot3StatsLateCollisions] = 1,
- [RTL8365MB_MIB_dot3StatsExcessiveCollisions] = 1,
+ u64 cnt[RTL8367C_MIB_END] = {
+ [RTL8367C_MIB_ifOutOctets] = 1,
+ [RTL8367C_MIB_ifOutUcastPkts] = 1,
+ [RTL8367C_MIB_ifOutMulticastPkts] = 1,
+ [RTL8367C_MIB_ifOutBroadcastPkts] = 1,
+ [RTL8367C_MIB_dot3OutPauseFrames] = 1,
+ [RTL8367C_MIB_ifOutDiscards] = 1,
+ [RTL8367C_MIB_ifInOctets] = 1,
+ [RTL8367C_MIB_ifInUcastPkts] = 1,
+ [RTL8367C_MIB_ifInMulticastPkts] = 1,
+ [RTL8367C_MIB_ifInBroadcastPkts] = 1,
+ [RTL8367C_MIB_dot3InPauseFrames] = 1,
+ [RTL8367C_MIB_dot3StatsSingleCollisionFrames] = 1,
+ [RTL8367C_MIB_dot3StatsMultipleCollisionFrames] = 1,
+ [RTL8367C_MIB_dot3StatsFCSErrors] = 1,
+ [RTL8367C_MIB_dot3StatsDeferredTransmissions] = 1,
+ [RTL8367C_MIB_dot3StatsLateCollisions] = 1,
+ [RTL8367C_MIB_dot3StatsExcessiveCollisions] = 1,
};
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb *mb;
+ struct rtl8367c *mb;
int ret;
int i;
mb = priv->chip_data;
mutex_lock(&mb->mib_lock);
- for (i = 0; i < RTL8365MB_MIB_END; i++) {
- struct rtl8365mb_mib_counter *mib = &rtl8365mb_mib_counters[i];
+ for (i = 0; i < RTL8367C_MIB_END; i++) {
+ struct rtl8367c_mib_counter *mib = &rtl8367c_mib_counters[i];
/* Only fetch required MIB counters (marked = 1 above) */
if (!cnt[i])
continue;
- ret = rtl8365mb_mib_counter_read(priv, port, mib->offset,
+ ret = rtl8367c_mib_counter_read(priv, port, mib->offset,
mib->length, &cnt[i]);
if (ret)
break;
@@ -1256,76 +1245,76 @@ static void rtl8365mb_get_mac_stats(struct dsa_switch *ds, int port,
* subject.
*/
- mac_stats->FramesTransmittedOK = cnt[RTL8365MB_MIB_ifOutUcastPkts] +
- cnt[RTL8365MB_MIB_ifOutMulticastPkts] +
- cnt[RTL8365MB_MIB_ifOutBroadcastPkts] +
- cnt[RTL8365MB_MIB_dot3OutPauseFrames] -
- cnt[RTL8365MB_MIB_ifOutDiscards];
+ mac_stats->FramesTransmittedOK = cnt[RTL8367C_MIB_ifOutUcastPkts] +
+ cnt[RTL8367C_MIB_ifOutMulticastPkts] +
+ cnt[RTL8367C_MIB_ifOutBroadcastPkts] +
+ cnt[RTL8367C_MIB_dot3OutPauseFrames] -
+ cnt[RTL8367C_MIB_ifOutDiscards];
mac_stats->SingleCollisionFrames =
- cnt[RTL8365MB_MIB_dot3StatsSingleCollisionFrames];
+ cnt[RTL8367C_MIB_dot3StatsSingleCollisionFrames];
mac_stats->MultipleCollisionFrames =
- cnt[RTL8365MB_MIB_dot3StatsMultipleCollisionFrames];
- mac_stats->FramesReceivedOK = cnt[RTL8365MB_MIB_ifInUcastPkts] +
- cnt[RTL8365MB_MIB_ifInMulticastPkts] +
- cnt[RTL8365MB_MIB_ifInBroadcastPkts] +
- cnt[RTL8365MB_MIB_dot3InPauseFrames];
+ cnt[RTL8367C_MIB_dot3StatsMultipleCollisionFrames];
+ mac_stats->FramesReceivedOK = cnt[RTL8367C_MIB_ifInUcastPkts] +
+ cnt[RTL8367C_MIB_ifInMulticastPkts] +
+ cnt[RTL8367C_MIB_ifInBroadcastPkts] +
+ cnt[RTL8367C_MIB_dot3InPauseFrames];
mac_stats->FrameCheckSequenceErrors =
- cnt[RTL8365MB_MIB_dot3StatsFCSErrors];
- mac_stats->OctetsTransmittedOK = cnt[RTL8365MB_MIB_ifOutOctets] -
+ cnt[RTL8367C_MIB_dot3StatsFCSErrors];
+ mac_stats->OctetsTransmittedOK = cnt[RTL8367C_MIB_ifOutOctets] -
18 * mac_stats->FramesTransmittedOK;
mac_stats->FramesWithDeferredXmissions =
- cnt[RTL8365MB_MIB_dot3StatsDeferredTransmissions];
- mac_stats->LateCollisions = cnt[RTL8365MB_MIB_dot3StatsLateCollisions];
+ cnt[RTL8367C_MIB_dot3StatsDeferredTransmissions];
+ mac_stats->LateCollisions = cnt[RTL8367C_MIB_dot3StatsLateCollisions];
mac_stats->FramesAbortedDueToXSColls =
- cnt[RTL8365MB_MIB_dot3StatsExcessiveCollisions];
- mac_stats->OctetsReceivedOK = cnt[RTL8365MB_MIB_ifInOctets] -
+ cnt[RTL8367C_MIB_dot3StatsExcessiveCollisions];
+ mac_stats->OctetsReceivedOK = cnt[RTL8367C_MIB_ifInOctets] -
18 * mac_stats->FramesReceivedOK;
mac_stats->MulticastFramesXmittedOK =
- cnt[RTL8365MB_MIB_ifOutMulticastPkts];
+ cnt[RTL8367C_MIB_ifOutMulticastPkts];
mac_stats->BroadcastFramesXmittedOK =
- cnt[RTL8365MB_MIB_ifOutBroadcastPkts];
+ cnt[RTL8367C_MIB_ifOutBroadcastPkts];
mac_stats->MulticastFramesReceivedOK =
- cnt[RTL8365MB_MIB_ifInMulticastPkts];
+ cnt[RTL8367C_MIB_ifInMulticastPkts];
mac_stats->BroadcastFramesReceivedOK =
- cnt[RTL8365MB_MIB_ifInBroadcastPkts];
+ cnt[RTL8367C_MIB_ifInBroadcastPkts];
}
-static void rtl8365mb_get_ctrl_stats(struct dsa_switch *ds, int port,
+static void rtl8367c_get_ctrl_stats(struct dsa_switch *ds, int port,
struct ethtool_eth_ctrl_stats *ctrl_stats)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb_mib_counter *mib;
- struct rtl8365mb *mb;
+ struct rtl8367c_mib_counter *mib;
+ struct rtl8367c *mb;
mb = priv->chip_data;
- mib = &rtl8365mb_mib_counters[RTL8365MB_MIB_dot3ControlInUnknownOpcodes];
+ mib = &rtl8367c_mib_counters[RTL8367C_MIB_dot3ControlInUnknownOpcodes];
mutex_lock(&mb->mib_lock);
- rtl8365mb_mib_counter_read(priv, port, mib->offset, mib->length,
+ rtl8367c_mib_counter_read(priv, port, mib->offset, mib->length,
&ctrl_stats->UnsupportedOpcodesReceived);
mutex_unlock(&mb->mib_lock);
}
-static void rtl8365mb_stats_update(struct realtek_priv *priv, int port)
+static void rtl8367c_stats_update(struct realtek_priv *priv, int port)
{
- u64 cnt[RTL8365MB_MIB_END] = {
- [RTL8365MB_MIB_ifOutOctets] = 1,
- [RTL8365MB_MIB_ifOutUcastPkts] = 1,
- [RTL8365MB_MIB_ifOutMulticastPkts] = 1,
- [RTL8365MB_MIB_ifOutBroadcastPkts] = 1,
- [RTL8365MB_MIB_ifOutDiscards] = 1,
- [RTL8365MB_MIB_ifInOctets] = 1,
- [RTL8365MB_MIB_ifInUcastPkts] = 1,
- [RTL8365MB_MIB_ifInMulticastPkts] = 1,
- [RTL8365MB_MIB_ifInBroadcastPkts] = 1,
- [RTL8365MB_MIB_etherStatsDropEvents] = 1,
- [RTL8365MB_MIB_etherStatsCollisions] = 1,
- [RTL8365MB_MIB_etherStatsFragments] = 1,
- [RTL8365MB_MIB_etherStatsJabbers] = 1,
- [RTL8365MB_MIB_dot3StatsFCSErrors] = 1,
- [RTL8365MB_MIB_dot3StatsLateCollisions] = 1,
+ u64 cnt[RTL8367C_MIB_END] = {
+ [RTL8367C_MIB_ifOutOctets] = 1,
+ [RTL8367C_MIB_ifOutUcastPkts] = 1,
+ [RTL8367C_MIB_ifOutMulticastPkts] = 1,
+ [RTL8367C_MIB_ifOutBroadcastPkts] = 1,
+ [RTL8367C_MIB_ifOutDiscards] = 1,
+ [RTL8367C_MIB_ifInOctets] = 1,
+ [RTL8367C_MIB_ifInUcastPkts] = 1,
+ [RTL8367C_MIB_ifInMulticastPkts] = 1,
+ [RTL8367C_MIB_ifInBroadcastPkts] = 1,
+ [RTL8367C_MIB_etherStatsDropEvents] = 1,
+ [RTL8367C_MIB_etherStatsCollisions] = 1,
+ [RTL8367C_MIB_etherStatsFragments] = 1,
+ [RTL8367C_MIB_etherStatsJabbers] = 1,
+ [RTL8367C_MIB_dot3StatsFCSErrors] = 1,
+ [RTL8367C_MIB_dot3StatsLateCollisions] = 1,
};
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
struct rtnl_link_stats64 *stats;
int ret;
int i;
@@ -1333,14 +1322,14 @@ static void rtl8365mb_stats_update(struct realtek_priv *priv, int port)
stats = &mb->ports[port].stats;
mutex_lock(&mb->mib_lock);
- for (i = 0; i < RTL8365MB_MIB_END; i++) {
- struct rtl8365mb_mib_counter *c = &rtl8365mb_mib_counters[i];
+ for (i = 0; i < RTL8367C_MIB_END; i++) {
+ struct rtl8367c_mib_counter *c = &rtl8367c_mib_counters[i];
/* Only fetch required MIB counters (marked = 1 above) */
if (!cnt[i])
continue;
- ret = rtl8365mb_mib_counter_read(priv, port, c->offset,
+ ret = rtl8367c_mib_counter_read(priv, port, c->offset,
c->length, &cnt[i]);
if (ret)
break;
@@ -1353,56 +1342,56 @@ static void rtl8365mb_stats_update(struct realtek_priv *priv, int port)
spin_lock(&mb->ports[port].stats_lock);
- stats->rx_packets = cnt[RTL8365MB_MIB_ifInUcastPkts] +
- cnt[RTL8365MB_MIB_ifInMulticastPkts] +
- cnt[RTL8365MB_MIB_ifInBroadcastPkts] -
- cnt[RTL8365MB_MIB_ifOutDiscards];
+ stats->rx_packets = cnt[RTL8367C_MIB_ifInUcastPkts] +
+ cnt[RTL8367C_MIB_ifInMulticastPkts] +
+ cnt[RTL8367C_MIB_ifInBroadcastPkts] -
+ cnt[RTL8367C_MIB_ifOutDiscards];
- stats->tx_packets = cnt[RTL8365MB_MIB_ifOutUcastPkts] +
- cnt[RTL8365MB_MIB_ifOutMulticastPkts] +
- cnt[RTL8365MB_MIB_ifOutBroadcastPkts];
+ stats->tx_packets = cnt[RTL8367C_MIB_ifOutUcastPkts] +
+ cnt[RTL8367C_MIB_ifOutMulticastPkts] +
+ cnt[RTL8367C_MIB_ifOutBroadcastPkts];
/* if{In,Out}Octets includes FCS - remove it */
- stats->rx_bytes = cnt[RTL8365MB_MIB_ifInOctets] - 4 * stats->rx_packets;
+ stats->rx_bytes = cnt[RTL8367C_MIB_ifInOctets] - 4 * stats->rx_packets;
stats->tx_bytes =
- cnt[RTL8365MB_MIB_ifOutOctets] - 4 * stats->tx_packets;
+ cnt[RTL8367C_MIB_ifOutOctets] - 4 * stats->tx_packets;
- stats->rx_dropped = cnt[RTL8365MB_MIB_etherStatsDropEvents];
- stats->tx_dropped = cnt[RTL8365MB_MIB_ifOutDiscards];
+ stats->rx_dropped = cnt[RTL8367C_MIB_etherStatsDropEvents];
+ stats->tx_dropped = cnt[RTL8367C_MIB_ifOutDiscards];
- stats->multicast = cnt[RTL8365MB_MIB_ifInMulticastPkts];
- stats->collisions = cnt[RTL8365MB_MIB_etherStatsCollisions];
+ stats->multicast = cnt[RTL8367C_MIB_ifInMulticastPkts];
+ stats->collisions = cnt[RTL8367C_MIB_etherStatsCollisions];
- stats->rx_length_errors = cnt[RTL8365MB_MIB_etherStatsFragments] +
- cnt[RTL8365MB_MIB_etherStatsJabbers];
- stats->rx_crc_errors = cnt[RTL8365MB_MIB_dot3StatsFCSErrors];
+ stats->rx_length_errors = cnt[RTL8367C_MIB_etherStatsFragments] +
+ cnt[RTL8367C_MIB_etherStatsJabbers];
+ stats->rx_crc_errors = cnt[RTL8367C_MIB_dot3StatsFCSErrors];
stats->rx_errors = stats->rx_length_errors + stats->rx_crc_errors;
- stats->tx_aborted_errors = cnt[RTL8365MB_MIB_ifOutDiscards];
- stats->tx_window_errors = cnt[RTL8365MB_MIB_dot3StatsLateCollisions];
+ stats->tx_aborted_errors = cnt[RTL8367C_MIB_ifOutDiscards];
+ stats->tx_window_errors = cnt[RTL8367C_MIB_dot3StatsLateCollisions];
stats->tx_errors = stats->tx_aborted_errors + stats->tx_window_errors;
spin_unlock(&mb->ports[port].stats_lock);
}
-static void rtl8365mb_stats_poll(struct work_struct *work)
+static void rtl8367c_stats_poll(struct work_struct *work)
{
- struct rtl8365mb_port *p = container_of(to_delayed_work(work),
- struct rtl8365mb_port,
+ struct rtl8367c_port *p = container_of(to_delayed_work(work),
+ struct rtl8367c_port,
mib_work);
struct realtek_priv *priv = p->priv;
- rtl8365mb_stats_update(priv, p->index);
+ rtl8367c_stats_update(priv, p->index);
- schedule_delayed_work(&p->mib_work, RTL8365MB_STATS_INTERVAL_JIFFIES);
+ schedule_delayed_work(&p->mib_work, RTL8367C_STATS_INTERVAL_JIFFIES);
}
-static void rtl8365mb_get_stats64(struct dsa_switch *ds, int port,
+static void rtl8367c_get_stats64(struct dsa_switch *ds, int port,
struct rtnl_link_stats64 *s)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb_port *p;
- struct rtl8365mb *mb;
+ struct rtl8367c_port *p;
+ struct rtl8367c *mb;
mb = priv->chip_data;
p = &mb->ports[port];
@@ -1412,9 +1401,9 @@ static void rtl8365mb_get_stats64(struct dsa_switch *ds, int port,
spin_unlock(&p->stats_lock);
}
-static void rtl8365mb_stats_setup(struct realtek_priv *priv)
+static void rtl8367c_stats_setup(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
int i;
/* Per-chip global mutex to protect MIB counter access, since doing
@@ -1423,7 +1412,7 @@ static void rtl8365mb_stats_setup(struct realtek_priv *priv)
mutex_init(&mb->mib_lock);
for (i = 0; i < priv->num_ports; i++) {
- struct rtl8365mb_port *p = &mb->ports[i];
+ struct rtl8367c_port *p = &mb->ports[i];
if (dsa_is_unused_port(priv->ds, i))
continue;
@@ -1434,17 +1423,17 @@ static void rtl8365mb_stats_setup(struct realtek_priv *priv)
/* This work polls the MIB counters and keeps the stats64 data
* up-to-date.
*/
- INIT_DELAYED_WORK(&p->mib_work, rtl8365mb_stats_poll);
+ INIT_DELAYED_WORK(&p->mib_work, rtl8367c_stats_poll);
}
}
-static void rtl8365mb_stats_teardown(struct realtek_priv *priv)
+static void rtl8367c_stats_teardown(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
int i;
for (i = 0; i < priv->num_ports; i++) {
- struct rtl8365mb_port *p = &mb->ports[i];
+ struct rtl8367c_port *p = &mb->ports[i];
if (dsa_is_unused_port(priv->ds, i))
continue;
@@ -1453,7 +1442,7 @@ static void rtl8365mb_stats_teardown(struct realtek_priv *priv)
}
}
-static int rtl8365mb_get_and_clear_status_reg(struct realtek_priv *priv, u32 reg,
+static int rtl8367c_get_and_clear_status_reg(struct realtek_priv *priv, u32 reg,
u32 *val)
{
int ret;
@@ -1465,40 +1454,40 @@ static int rtl8365mb_get_and_clear_status_reg(struct realtek_priv *priv, u32 reg
return regmap_write(priv->map, reg, *val);
}
-static irqreturn_t rtl8365mb_irq(int irq, void *data)
+static irqreturn_t rtl8367c_irq(int irq, void *data)
{
struct realtek_priv *priv = data;
unsigned long line_changes = 0;
- struct rtl8365mb *mb;
+ struct rtl8367c *mb;
u32 stat;
int line;
int ret;
mb = priv->chip_data;
- ret = rtl8365mb_get_and_clear_status_reg(priv, RTL8365MB_INTR_STATUS_REG,
+ ret = rtl8367c_get_and_clear_status_reg(priv, RTL8367C_INTR_STATUS_REG,
&stat);
if (ret)
goto out_error;
- if (stat & RTL8365MB_INTR_LINK_CHANGE_MASK) {
+ if (stat & RTL8367C_INTR_LINK_CHANGE_MASK) {
u32 linkdown_ind;
u32 linkup_ind;
u32 val;
- ret = rtl8365mb_get_and_clear_status_reg(
- priv, RTL8365MB_PORT_LINKUP_IND_REG, &val);
+ ret = rtl8367c_get_and_clear_status_reg(
+ priv, RTL8367C_PORT_LINKUP_IND_REG, &val);
if (ret)
goto out_error;
- linkup_ind = FIELD_GET(RTL8365MB_PORT_LINKUP_IND_MASK, val);
+ linkup_ind = FIELD_GET(RTL8367C_PORT_LINKUP_IND_MASK, val);
- ret = rtl8365mb_get_and_clear_status_reg(
- priv, RTL8365MB_PORT_LINKDOWN_IND_REG, &val);
+ ret = rtl8367c_get_and_clear_status_reg(
+ priv, RTL8367C_PORT_LINKDOWN_IND_REG, &val);
if (ret)
goto out_error;
- linkdown_ind = FIELD_GET(RTL8365MB_PORT_LINKDOWN_IND_MASK, val);
+ linkdown_ind = FIELD_GET(RTL8367C_PORT_LINKDOWN_IND_MASK, val);
line_changes = (linkup_ind | linkdown_ind) & mb->port_mask;
}
@@ -1521,56 +1510,56 @@ static irqreturn_t rtl8365mb_irq(int irq, void *data)
return IRQ_NONE;
}
-static struct irq_chip rtl8365mb_irq_chip = {
- .name = "rtl8365mb",
+static struct irq_chip rtl8367c_irq_chip = {
+ .name = "rtl8367c",
/* The hardware doesn't support masking IRQs on a per-port basis */
};
-static int rtl8365mb_irq_map(struct irq_domain *domain, unsigned int irq,
+static int rtl8367c_irq_map(struct irq_domain *domain, unsigned int irq,
irq_hw_number_t hwirq)
{
irq_set_chip_data(irq, domain->host_data);
- irq_set_chip_and_handler(irq, &rtl8365mb_irq_chip, handle_simple_irq);
+ irq_set_chip_and_handler(irq, &rtl8367c_irq_chip, handle_simple_irq);
irq_set_nested_thread(irq, 1);
irq_set_noprobe(irq);
return 0;
}
-static void rtl8365mb_irq_unmap(struct irq_domain *d, unsigned int irq)
+static void rtl8367c_irq_unmap(struct irq_domain *d, unsigned int irq)
{
irq_set_nested_thread(irq, 0);
irq_set_chip_and_handler(irq, NULL, NULL);
irq_set_chip_data(irq, NULL);
}
-static const struct irq_domain_ops rtl8365mb_irqdomain_ops = {
- .map = rtl8365mb_irq_map,
- .unmap = rtl8365mb_irq_unmap,
+static const struct irq_domain_ops rtl8367c_irqdomain_ops = {
+ .map = rtl8367c_irq_map,
+ .unmap = rtl8367c_irq_unmap,
.xlate = irq_domain_xlate_onecell,
};
-static int rtl8365mb_set_irq_enable(struct realtek_priv *priv, bool enable)
+static int rtl8367c_set_irq_enable(struct realtek_priv *priv, bool enable)
{
- return regmap_update_bits(priv->map, RTL8365MB_INTR_CTRL_REG,
- RTL8365MB_INTR_LINK_CHANGE_MASK,
- FIELD_PREP(RTL8365MB_INTR_LINK_CHANGE_MASK,
+ return regmap_update_bits(priv->map, RTL8367C_INTR_CTRL_REG,
+ RTL8367C_INTR_LINK_CHANGE_MASK,
+ FIELD_PREP(RTL8367C_INTR_LINK_CHANGE_MASK,
enable ? 1 : 0));
}
-static int rtl8365mb_irq_enable(struct realtek_priv *priv)
+static int rtl8367c_irq_enable(struct realtek_priv *priv)
{
- return rtl8365mb_set_irq_enable(priv, true);
+ return rtl8367c_set_irq_enable(priv, true);
}
-static int rtl8365mb_irq_disable(struct realtek_priv *priv)
+static int rtl8367c_irq_disable(struct realtek_priv *priv)
{
- return rtl8365mb_set_irq_enable(priv, false);
+ return rtl8367c_set_irq_enable(priv, false);
}
-static int rtl8365mb_irq_setup(struct realtek_priv *priv)
+static int rtl8367c_irq_setup(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
struct device_node *intc;
u32 irq_trig;
int virq;
@@ -1585,7 +1574,7 @@ static int rtl8365mb_irq_setup(struct realtek_priv *priv)
return -EINVAL;
}
- /* rtl8365mb IRQs cascade off this one */
+ /* rtl8367c IRQs cascade off this one */
irq = of_irq_get(intc, 0);
if (irq <= 0) {
if (irq != -EPROBE_DEFER)
@@ -1596,7 +1585,7 @@ static int rtl8365mb_irq_setup(struct realtek_priv *priv)
}
priv->irqdomain = irq_domain_add_linear(intc, priv->num_ports,
- &rtl8365mb_irqdomain_ops, priv);
+ &rtl8367c_irqdomain_ops, priv);
if (!priv->irqdomain) {
dev_err(priv->dev, "failed to add irq domain\n");
ret = -ENOMEM;
@@ -1620,11 +1609,11 @@ static int rtl8365mb_irq_setup(struct realtek_priv *priv)
switch (irq_trig) {
case IRQF_TRIGGER_RISING:
case IRQF_TRIGGER_HIGH:
- val = RTL8365MB_INTR_POLARITY_HIGH;
+ val = RTL8367C_INTR_POLARITY_HIGH;
break;
case IRQF_TRIGGER_FALLING:
case IRQF_TRIGGER_LOW:
- val = RTL8365MB_INTR_POLARITY_LOW;
+ val = RTL8367C_INTR_POLARITY_LOW;
break;
default:
dev_err(priv->dev, "unsupported irq trigger type %u\n",
@@ -1633,25 +1622,25 @@ static int rtl8365mb_irq_setup(struct realtek_priv *priv)
goto out_remove_irqdomain;
}
- ret = regmap_update_bits(priv->map, RTL8365MB_INTR_POLARITY_REG,
- RTL8365MB_INTR_POLARITY_MASK,
- FIELD_PREP(RTL8365MB_INTR_POLARITY_MASK, val));
+ ret = regmap_update_bits(priv->map, RTL8367C_INTR_POLARITY_REG,
+ RTL8367C_INTR_POLARITY_MASK,
+ FIELD_PREP(RTL8367C_INTR_POLARITY_MASK, val));
if (ret)
goto out_remove_irqdomain;
/* Disable the interrupt in case the chip has it enabled on reset */
- ret = rtl8365mb_irq_disable(priv);
+ ret = rtl8367c_irq_disable(priv);
if (ret)
goto out_remove_irqdomain;
/* Clear the interrupt status register */
- ret = regmap_write(priv->map, RTL8365MB_INTR_STATUS_REG,
- RTL8365MB_INTR_ALL_MASK);
+ ret = regmap_write(priv->map, RTL8367C_INTR_STATUS_REG,
+ RTL8367C_INTR_ALL_MASK);
if (ret)
goto out_remove_irqdomain;
- ret = request_threaded_irq(irq, NULL, rtl8365mb_irq, IRQF_ONESHOT,
- "rtl8365mb", priv);
+ ret = request_threaded_irq(irq, NULL, rtl8367c_irq, IRQF_ONESHOT,
+ "rtl8367c", priv);
if (ret) {
dev_err(priv->dev, "failed to request irq: %d\n", ret);
goto out_remove_irqdomain;
@@ -1660,7 +1649,7 @@ static int rtl8365mb_irq_setup(struct realtek_priv *priv)
/* Store the irq so that we know to free it during teardown */
mb->irq = irq;
- ret = rtl8365mb_irq_enable(priv);
+ ret = rtl8367c_irq_enable(priv);
if (ret)
goto out_free_irq;
@@ -1687,9 +1676,9 @@ static int rtl8365mb_irq_setup(struct realtek_priv *priv)
return ret;
}
-static void rtl8365mb_irq_teardown(struct realtek_priv *priv)
+static void rtl8367c_irq_teardown(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
int virq;
int i;
@@ -1709,38 +1698,38 @@ static void rtl8365mb_irq_teardown(struct realtek_priv *priv)
}
}
-static int rtl8365mb_cpu_config(struct realtek_priv *priv)
+static int rtl8367c_cpu_config(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
- struct rtl8365mb_cpu *cpu = &mb->cpu;
+ struct rtl8367c *mb = priv->chip_data;
+ struct rtl8367c_cpu *cpu = &mb->cpu;
u32 val;
int ret;
- ret = regmap_update_bits(priv->map, RTL8365MB_CPU_PORT_MASK_REG,
- RTL8365MB_CPU_PORT_MASK_MASK,
- FIELD_PREP(RTL8365MB_CPU_PORT_MASK_MASK,
+ ret = regmap_update_bits(priv->map, RTL8367C_CPU_PORT_MASK_REG,
+ RTL8367C_CPU_PORT_MASK_MASK,
+ FIELD_PREP(RTL8367C_CPU_PORT_MASK_MASK,
cpu->mask));
if (ret)
return ret;
- val = FIELD_PREP(RTL8365MB_CPU_CTRL_EN_MASK, cpu->enable ? 1 : 0) |
- FIELD_PREP(RTL8365MB_CPU_CTRL_INSERTMODE_MASK, cpu->insert) |
- FIELD_PREP(RTL8365MB_CPU_CTRL_TAG_POSITION_MASK, cpu->position) |
- FIELD_PREP(RTL8365MB_CPU_CTRL_RXBYTECOUNT_MASK, cpu->rx_length) |
- FIELD_PREP(RTL8365MB_CPU_CTRL_TAG_FORMAT_MASK, cpu->format) |
- FIELD_PREP(RTL8365MB_CPU_CTRL_TRAP_PORT_MASK, cpu->trap_port) |
- FIELD_PREP(RTL8365MB_CPU_CTRL_TRAP_PORT_EXT_MASK,
+ val = FIELD_PREP(RTL8367C_CPU_CTRL_EN_MASK, cpu->enable ? 1 : 0) |
+ FIELD_PREP(RTL8367C_CPU_CTRL_INSERTMODE_MASK, cpu->insert) |
+ FIELD_PREP(RTL8367C_CPU_CTRL_TAG_POSITION_MASK, cpu->position) |
+ FIELD_PREP(RTL8367C_CPU_CTRL_RXBYTECOUNT_MASK, cpu->rx_length) |
+ FIELD_PREP(RTL8367C_CPU_CTRL_TAG_FORMAT_MASK, cpu->format) |
+ FIELD_PREP(RTL8367C_CPU_CTRL_TRAP_PORT_MASK, cpu->trap_port) |
+ FIELD_PREP(RTL8367C_CPU_CTRL_TRAP_PORT_EXT_MASK,
cpu->trap_port >> 3);
- ret = regmap_write(priv->map, RTL8365MB_CPU_CTRL_REG, val);
+ ret = regmap_write(priv->map, RTL8367C_CPU_CTRL_REG, val);
if (ret)
return ret;
return 0;
}
-static int rtl8365mb_switch_init(struct realtek_priv *priv)
+static int rtl8367c_switch_init(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
int ret;
int i;
@@ -1755,9 +1744,9 @@ static int rtl8365mb_switch_init(struct realtek_priv *priv)
}
/* Common init jam */
- for (i = 0; i < ARRAY_SIZE(rtl8365mb_init_jam_common); i++) {
- ret = regmap_write(priv->map, rtl8365mb_init_jam_common[i].reg,
- rtl8365mb_init_jam_common[i].val);
+ for (i = 0; i < ARRAY_SIZE(rtl8367c_init_jam_common); i++) {
+ ret = regmap_write(priv->map, rtl8367c_init_jam_common[i].reg,
+ rtl8367c_init_jam_common[i].val);
if (ret)
return ret;
}
@@ -1765,60 +1754,60 @@ static int rtl8365mb_switch_init(struct realtek_priv *priv)
return 0;
}
-static int rtl8365mb_reset_chip(struct realtek_priv *priv)
+static int rtl8367c_reset_chip(struct realtek_priv *priv)
{
u32 val;
- priv->write_reg_noack(priv, RTL8365MB_CHIP_RESET_REG,
- FIELD_PREP(RTL8365MB_CHIP_RESET_HW_MASK,
+ priv->write_reg_noack(priv, RTL8367C_CHIP_RESET_REG,
+ FIELD_PREP(RTL8367C_CHIP_RESET_HW_MASK,
1));
/* Realtek documentation says the chip needs 1 second to reset. Sleep
* for 100 ms before accessing any registers to prevent ACK timeouts.
*/
msleep(100);
- return regmap_read_poll_timeout(priv->map, RTL8365MB_CHIP_RESET_REG, val,
- !(val & RTL8365MB_CHIP_RESET_HW_MASK),
+ return regmap_read_poll_timeout(priv->map, RTL8367C_CHIP_RESET_REG, val,
+ !(val & RTL8367C_CHIP_RESET_HW_MASK),
20000, 1e6);
}
-static int rtl8365mb_setup(struct dsa_switch *ds)
+static int rtl8367c_setup(struct dsa_switch *ds)
{
struct realtek_priv *priv = ds->priv;
- struct rtl8365mb *mb;
+ struct rtl8367c *mb;
int ret;
int i;
mb = priv->chip_data;
- ret = rtl8365mb_reset_chip(priv);
+ ret = rtl8367c_reset_chip(priv);
if (ret) {
dev_err(priv->dev, "failed to reset chip: %d\n", ret);
goto out_error;
}
/* Configure switch to vendor-defined initial state */
- ret = rtl8365mb_switch_init(priv);
+ ret = rtl8367c_switch_init(priv);
if (ret) {
dev_err(priv->dev, "failed to initialize switch: %d\n", ret);
goto out_error;
}
/* Set up cascading IRQs */
- ret = rtl8365mb_irq_setup(priv);
+ ret = rtl8367c_irq_setup(priv);
if (ret == -EPROBE_DEFER)
return ret;
else if (ret)
dev_info(priv->dev, "no interrupt support\n");
/* Configure CPU tagging */
- ret = rtl8365mb_cpu_config(priv);
+ ret = rtl8367c_cpu_config(priv);
if (ret)
goto out_teardown_irq;
/* Configure ports */
for (i = 0; i < priv->num_ports; i++) {
- struct rtl8365mb_port *p = &mb->ports[i];
+ struct rtl8367c_port *p = &mb->ports[i];
if (dsa_is_unused_port(priv->ds, i))
continue;
@@ -1828,12 +1817,12 @@ static int rtl8365mb_setup(struct dsa_switch *ds)
p->index = i;
/* Forward only to the CPU */
- ret = rtl8365mb_port_set_isolation(priv, i, BIT(priv->cpu_port));
+ ret = rtl8367c_port_set_isolation(priv, i, BIT(priv->cpu_port));
if (ret)
goto out_teardown_irq;
/* Disable learning */
- ret = rtl8365mb_port_set_learning(priv, i, false);
+ ret = rtl8367c_port_set_learning(priv, i, false);
if (ret)
goto out_teardown_irq;
@@ -1841,13 +1830,13 @@ static int rtl8365mb_setup(struct dsa_switch *ds)
* ports will still forward frames to the CPU despite being
* administratively down by default.
*/
- rtl8365mb_port_stp_state_set(priv->ds, i, BR_STATE_DISABLED);
+ rtl8367c_port_stp_state_set(priv->ds, i, BR_STATE_DISABLED);
}
/* Set maximum packet length to 1536 bytes */
- ret = regmap_update_bits(priv->map, RTL8365MB_CFG0_MAX_LEN_REG,
- RTL8365MB_CFG0_MAX_LEN_MASK,
- FIELD_PREP(RTL8365MB_CFG0_MAX_LEN_MASK, 1536));
+ ret = regmap_update_bits(priv->map, RTL8367C_CFG0_MAX_LEN_REG,
+ RTL8367C_CFG0_MAX_LEN_MASK,
+ FIELD_PREP(RTL8367C_CFG0_MAX_LEN_MASK, 1536));
if (ret)
goto out_teardown_irq;
@@ -1860,60 +1849,60 @@ static int rtl8365mb_setup(struct dsa_switch *ds)
}
/* Start statistics counter polling */
- rtl8365mb_stats_setup(priv);
+ rtl8367c_stats_setup(priv);
return 0;
out_teardown_irq:
- rtl8365mb_irq_teardown(priv);
+ rtl8367c_irq_teardown(priv);
out_error:
return ret;
}
-static void rtl8365mb_teardown(struct dsa_switch *ds)
+static void rtl8367c_teardown(struct dsa_switch *ds)
{
struct realtek_priv *priv = ds->priv;
- rtl8365mb_stats_teardown(priv);
- rtl8365mb_irq_teardown(priv);
+ rtl8367c_stats_teardown(priv);
+ rtl8367c_irq_teardown(priv);
}
-static int rtl8365mb_get_chip_id_and_ver(struct regmap *map, u32 *id, u32 *ver)
+static int rtl8367c_get_chip_id_and_ver(struct regmap *map, u32 *id, u32 *ver)
{
int ret;
/* For some reason we have to write a magic value to an arbitrary
* register whenever accessing the chip ID/version registers.
*/
- ret = regmap_write(map, RTL8365MB_MAGIC_REG, RTL8365MB_MAGIC_VALUE);
+ ret = regmap_write(map, RTL8367C_MAGIC_REG, RTL8367C_MAGIC_VALUE);
if (ret)
return ret;
- ret = regmap_read(map, RTL8365MB_CHIP_ID_REG, id);
+ ret = regmap_read(map, RTL8367C_CHIP_ID_REG, id);
if (ret)
return ret;
- ret = regmap_read(map, RTL8365MB_CHIP_VER_REG, ver);
+ ret = regmap_read(map, RTL8367C_CHIP_VER_REG, ver);
if (ret)
return ret;
/* Reset magic register */
- ret = regmap_write(map, RTL8365MB_MAGIC_REG, 0);
+ ret = regmap_write(map, RTL8367C_MAGIC_REG, 0);
if (ret)
return ret;
return 0;
}
-static int rtl8365mb_detect(struct realtek_priv *priv)
+static int rtl8367c_detect(struct realtek_priv *priv)
{
- struct rtl8365mb *mb = priv->chip_data;
+ struct rtl8367c *mb = priv->chip_data;
u32 chip_id;
u32 chip_ver;
int ret;
- ret = rtl8365mb_get_chip_id_and_ver(priv->map, &chip_id, &chip_ver);
+ ret = rtl8367c_get_chip_id_and_ver(priv->map, &chip_id, &chip_ver);
if (ret) {
dev_err(priv->dev, "failed to read chip id and version: %d\n",
ret);
@@ -1921,29 +1910,29 @@ static int rtl8365mb_detect(struct realtek_priv *priv)
}
switch (chip_id) {
- case RTL8365MB_CHIP_ID_8365MB_VC:
+ case RTL8367C_CHIP_ID_8365MB_VC:
dev_info(priv->dev,
- "found an RTL8365MB-VC switch (ver=0x%04x)\n",
- chip_ver);
+ "found an RTL8365MB-VC switch (ver=0x%04x)\n",
+ chip_ver);
- priv->cpu_port = RTL8365MB_CPU_PORT_NUM_8365MB_VC;
+ priv->cpu_port = RTL8367C_CPU_PORT_NUM_8365MB_VC;
priv->num_ports = priv->cpu_port + 1;
mb->priv = priv;
mb->chip_id = chip_id;
mb->chip_ver = chip_ver;
mb->port_mask = BIT(priv->num_ports) - 1;
- mb->learn_limit_max = RTL8365MB_LEARN_LIMIT_MAX_8365MB_VC;
- mb->jam_table = rtl8365mb_init_jam_8365mb_vc;
- mb->jam_size = ARRAY_SIZE(rtl8365mb_init_jam_8365mb_vc);
+ mb->learn_limit_max = RTL8367C_LEARN_LIMIT_MAX;
+ mb->jam_table = rtl8367c_init_jam_8367c;
+ mb->jam_size = ARRAY_SIZE(rtl8367c_init_jam_8367c);
mb->cpu.enable = 1;
mb->cpu.mask = BIT(priv->cpu_port);
mb->cpu.trap_port = priv->cpu_port;
- mb->cpu.insert = RTL8365MB_CPU_INSERT_TO_ALL;
- mb->cpu.position = RTL8365MB_CPU_POS_AFTER_SA;
- mb->cpu.rx_length = RTL8365MB_CPU_RXLEN_64BYTES;
- mb->cpu.format = RTL8365MB_CPU_FORMAT_8BYTES;
+ mb->cpu.insert = RTL8367C_CPU_INSERT_TO_ALL;
+ mb->cpu.position = RTL8367C_CPU_POS_AFTER_SA;
+ mb->cpu.rx_length = RTL8367C_CPU_RXLEN_64BYTES;
+ mb->cpu.format = RTL8367C_CPU_FORMAT_8BYTES;
break;
default:
@@ -1956,38 +1945,38 @@ static int rtl8365mb_detect(struct realtek_priv *priv)
return 0;
}
-static const struct dsa_switch_ops rtl8365mb_switch_ops = {
- .get_tag_protocol = rtl8365mb_get_tag_protocol,
- .setup = rtl8365mb_setup,
- .teardown = rtl8365mb_teardown,
- .phy_read = rtl8365mb_phy_read,
- .phy_write = rtl8365mb_phy_write,
- .phylink_validate = rtl8365mb_phylink_validate,
- .phylink_mac_config = rtl8365mb_phylink_mac_config,
- .phylink_mac_link_down = rtl8365mb_phylink_mac_link_down,
- .phylink_mac_link_up = rtl8365mb_phylink_mac_link_up,
- .port_stp_state_set = rtl8365mb_port_stp_state_set,
- .get_strings = rtl8365mb_get_strings,
- .get_ethtool_stats = rtl8365mb_get_ethtool_stats,
- .get_sset_count = rtl8365mb_get_sset_count,
- .get_eth_phy_stats = rtl8365mb_get_phy_stats,
- .get_eth_mac_stats = rtl8365mb_get_mac_stats,
- .get_eth_ctrl_stats = rtl8365mb_get_ctrl_stats,
- .get_stats64 = rtl8365mb_get_stats64,
+static const struct dsa_switch_ops rtl8367c_switch_ops = {
+ .get_tag_protocol = rtl8367c_get_tag_protocol,
+ .setup = rtl8367c_setup,
+ .teardown = rtl8367c_teardown,
+ .phy_read = rtl8367c_phy_read,
+ .phy_write = rtl8367c_phy_write,
+ .phylink_validate = rtl8367c_phylink_validate,
+ .phylink_mac_config = rtl8367c_phylink_mac_config,
+ .phylink_mac_link_down = rtl8367c_phylink_mac_link_down,
+ .phylink_mac_link_up = rtl8367c_phylink_mac_link_up,
+ .port_stp_state_set = rtl8367c_port_stp_state_set,
+ .get_strings = rtl8367c_get_strings,
+ .get_ethtool_stats = rtl8367c_get_ethtool_stats,
+ .get_sset_count = rtl8367c_get_sset_count,
+ .get_eth_phy_stats = rtl8367c_get_phy_stats,
+ .get_eth_mac_stats = rtl8367c_get_mac_stats,
+ .get_eth_ctrl_stats = rtl8367c_get_ctrl_stats,
+ .get_stats64 = rtl8367c_get_stats64,
};
-static const struct realtek_ops rtl8365mb_ops = {
- .detect = rtl8365mb_detect,
+static const struct realtek_ops rtl8367c_ops = {
+ .detect = rtl8367c_detect,
};
-const struct realtek_variant rtl8365mb_variant = {
- .ds_ops = &rtl8365mb_switch_ops,
- .ops = &rtl8365mb_ops,
+const struct realtek_variant rtl8367c_variant = {
+ .ds_ops = &rtl8367c_switch_ops,
+ .ops = &rtl8367c_ops,
.clk_delay = 10,
.cmd_read = 0xb9,
.cmd_write = 0xb8,
- .chip_data_sz = sizeof(struct rtl8365mb),
+ .chip_data_sz = sizeof(struct rtl8367c),
};
-EXPORT_SYMBOL_GPL(rtl8365mb_variant);
+EXPORT_SYMBOL_GPL(rtl8367c_variant);
MODULE_LICENSE("GPL");
diff --git a/drivers/net/phy/realtek.c b/drivers/net/phy/realtek.c
index a5671ab896b3..4574782ae52e 100644
--- a/drivers/net/phy/realtek.c
+++ b/drivers/net/phy/realtek.c
@@ -1025,7 +1025,7 @@ static struct phy_driver realtek_drvs[] = {
.write_page = rtl821x_write_page,
}, {
PHY_ID_MATCH_EXACT(0x001cc942),
- .name = "RTL8365MB-VC Gigabit Ethernet",
+ .name = "RTL8367C Gigabit Ethernet",
/* Interrupt handling analogous to RTL8366RB */
.config_intr = genphy_no_config_intr,
.handle_interrupt = genphy_handle_interrupt_no_ack,
--
2.34.0
next prev parent reply other threads:[~2021-12-16 20:14 UTC|newest]
Thread overview: 94+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-12-16 20:13 [PATCH net-next 00/13] net: dsa: realtek: MDIO interface and RTL8367S luizluca
2021-12-16 20:13 ` [PATCH net-next 01/13] dt-bindings: net: dsa: realtek-smi: remove unsupported switches luizluca
2021-12-16 23:20 ` Alvin Šipraga
2021-12-18 2:41 ` Linus Walleij
2021-12-18 6:12 ` Luiz Angelo Daros de Luca
2021-12-19 22:27 ` Linus Walleij
2021-12-16 20:13 ` [PATCH net-next 02/13] net: dsa: realtek-smi: move to subdirectory luizluca
2021-12-16 23:21 ` Alvin Šipraga
2021-12-18 2:41 ` Linus Walleij
2021-12-16 20:13 ` [PATCH net-next 03/13] net: dsa: realtek: rename realtek_smi to realtek_priv luizluca
2021-12-16 23:22 ` Alvin Šipraga
2021-12-17 6:21 ` Luiz Angelo Daros de Luca
2021-12-18 2:45 ` Linus Walleij
2021-12-18 6:15 ` Luiz Angelo Daros de Luca
2021-12-17 9:21 ` Andrew Lunn
2021-12-16 20:13 ` [PATCH net-next 04/13] net: dsa: realtek: convert subdrivers into modules luizluca
2021-12-16 23:29 ` Alvin Šipraga
2021-12-17 6:50 ` Luiz Angelo Daros de Luca
2021-12-17 2:31 ` kernel test robot
2021-12-17 2:31 ` kernel test robot
2021-12-16 20:13 ` [PATCH net-next 05/13] net: dsa: realtek: use phy_read in ds->ops luizluca
2021-12-18 2:50 ` Linus Walleij
2021-12-18 6:24 ` Luiz Angelo Daros de Luca
2021-12-16 20:13 ` [PATCH net-next 06/13] net: dsa: rtl8365mb: move rtl8365mb.c to rtl8367c.c luizluca
2021-12-19 22:29 ` Linus Walleij
2021-12-19 23:21 ` Alvin Šipraga
2021-12-16 20:13 ` luizluca [this message]
2021-12-16 23:41 ` [PATCH net-next 07/13] net: dsa: rtl8365mb: rename rtl8365mb to rtl8367c Alvin Šipraga
2021-12-17 7:24 ` Luiz Angelo Daros de Luca
2021-12-17 12:15 ` Alvin Šipraga
2021-12-17 22:50 ` Arınç ÜNAL
2021-12-18 6:08 ` Luiz Angelo Daros de Luca
2021-12-17 10:57 ` Arınç ÜNAL
2021-12-16 20:13 ` [PATCH net-next 08/13] net: dsa: realtek: add new mdio interface for drivers luizluca
2021-12-17 0:11 ` Alvin Šipraga
2021-12-17 3:33 ` kernel test robot
2021-12-17 3:33 ` kernel test robot
2021-12-18 2:54 ` Linus Walleij
2021-12-16 20:13 ` [PATCH net-next 09/13] dt-bindings: net: dsa: realtek-mdio: document new interface luizluca
2021-12-18 2:57 ` Linus Walleij
2021-12-18 6:26 ` Luiz Angelo Daros de Luca
2021-12-16 20:13 ` [PATCH net-next 10/13] net: dsa: realtek: rtl8367c: rename extport to extint, add "realtek,ext-int" luizluca
2021-12-16 20:13 ` [PATCH net-next 11/13] net: dsa: realtek: rtl8367c: use GENMASK(n-1,0) instead of BIT(n)-1 luizluca
2021-12-18 2:59 ` Linus Walleij
2021-12-19 20:06 ` Florian Fainelli
2021-12-19 20:28 ` Luiz Angelo Daros de Luca
2021-12-16 20:13 ` [PATCH net-next 12/13] net: dsa: realtek: rtl8367c: use DSA CPU port luizluca
2021-12-16 20:13 ` [PATCH net-next 13/13] net: dsa: realtek: rtl8367c: add RTL8367S support luizluca
2021-12-16 22:30 ` [PATCH net-next 00/13] net: dsa: realtek: MDIO interface and RTL8367S Arınç ÜNAL
2021-12-17 0:25 ` Jakub Kicinski
2021-12-17 8:53 ` Luiz Angelo Daros de Luca
2021-12-17 9:26 ` Andrew Lunn
2021-12-17 10:19 ` Luiz Angelo Daros de Luca
2021-12-18 8:14 ` Luiz Angelo Daros de Luca
2021-12-18 8:14 ` [PATCH net-next v2 01/13] dt-bindings: net: dsa: realtek-smi: mark unsupported switches Luiz Angelo Daros de Luca
2021-12-19 19:46 ` Linus Walleij
2021-12-18 8:14 ` [PATCH net-next v2 02/13] net: dsa: realtek-smi: move to subdirectory Luiz Angelo Daros de Luca
2021-12-19 21:43 ` Alvin Šipraga
2021-12-18 8:14 ` [PATCH net-next v2 03/13] net: dsa: realtek: rename realtek_smi to realtek_priv Luiz Angelo Daros de Luca
2021-12-19 22:24 ` Linus Walleij
2021-12-18 8:14 ` [PATCH net-next v2 04/13] net: dsa: realtek: remove direct calls to realtek-smi Luiz Angelo Daros de Luca
2021-12-18 8:14 ` [PATCH net-next v2 05/13] net: dsa: realtek: convert subdrivers into modules Luiz Angelo Daros de Luca
2021-12-19 22:25 ` Linus Walleij
2021-12-18 8:14 ` [PATCH net-next v2 06/13] net: dsa: realtek: use phy_read in ds->ops Luiz Angelo Daros de Luca
2021-12-19 19:58 ` Florian Fainelli
2021-12-30 19:44 ` Luiz Angelo Daros de Luca
2021-12-30 20:00 ` Andrew Lunn
2021-12-31 2:30 ` Luiz Angelo Daros de Luca
2021-12-18 8:14 ` [PATCH net-next v2 07/13] net: dsa: realtek: add new mdio interface for drivers Luiz Angelo Daros de Luca
2021-12-19 21:17 ` Alvin Šipraga
2021-12-19 21:44 ` Andrew Lunn
2021-12-19 22:32 ` Linus Walleij
2021-12-28 8:21 ` Luiz Angelo Daros de Luca
2021-12-28 9:57 ` Andrew Lunn
2021-12-31 3:10 ` Luiz Angelo Daros de Luca
2021-12-20 14:49 ` kernel test robot
2021-12-20 14:49 ` kernel test robot
2021-12-18 8:14 ` [PATCH net-next v2 08/13] dt-bindings: net: dsa: realtek-mdio: document new interface Luiz Angelo Daros de Luca
2021-12-19 19:57 ` Florian Fainelli
2021-12-19 21:53 ` Arınç ÜNAL
2021-12-20 7:50 ` Arınç ÜNAL
2021-12-18 8:14 ` [PATCH net-next v2 09/13] net: dsa: realtek: rtl8365mb: rename extport to extint, add "realtek,ext-int" Luiz Angelo Daros de Luca
2021-12-19 22:45 ` Alvin Šipraga
2021-12-18 8:14 ` [PATCH net-next v2 10/13] net: dsa: realtek: rtl8365mb: use GENMASK(n-1,0) instead of BIT(n)-1 Luiz Angelo Daros de Luca
2021-12-18 8:14 ` [PATCH net-next v2 11/13] net: dsa: realtek: rtl8365mb: use DSA CPU port Luiz Angelo Daros de Luca
2021-12-19 22:19 ` Vladimir Oltean
2021-12-19 23:19 ` Alvin Šipraga
2021-12-28 8:48 ` Luiz Angelo Daros de Luca
2021-12-18 8:14 ` [PATCH net-next v2 12/13] net: dsa: realtek: rtl8365mb: add RTL8367S support Luiz Angelo Daros de Luca
2021-12-19 21:43 ` Alvin Šipraga
2021-12-31 0:18 ` Luiz Angelo Daros de Luca
2021-12-18 8:14 ` [PATCH net-next v2 13/13] dt-bindings: net: dsa: realtek-{smi,mdio}: add rtl8367s Luiz Angelo Daros de Luca
2021-12-18 8:19 ` net: dsa: realtek: MDIO interface and RTL8367S Luiz Angelo Daros de Luca
2021-12-19 23:28 ` Alvin Šipraga
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20211216201342.25587-8-luizluca@gmail.com \
--to=luizluca@gmail.com \
--cc=alsi@bang-olufsen.dk \
--cc=andrew@lunn.ch \
--cc=arinc.unal@arinc9.com \
--cc=f.fainelli@gmail.com \
--cc=linus.walleij@linaro.org \
--cc=netdev@vger.kernel.org \
--cc=olteanv@gmail.com \
--cc=vivien.didelot@gmail.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.