Re: [PATCH net-next 03/13] net: dsa: realtek: rename realtek_smi to realtek_priv

Tested-by: Arınç ÜNAL <redacted>
Signed-off-by: Luiz Angelo Daros de Luca <luizluca@gmail.com>
---
  drivers/net/dsa/realtek/realtek-smi-core.c    | 314 +++++++-------
  .../realtek/{realtek-smi-core.h => realtek.h} |  71 ++--
  drivers/net/dsa/realtek/rtl8365mb.c           | 400 +++++++++---------
  drivers/net/dsa/realtek/rtl8366.c             | 164 +++----
  drivers/net/dsa/realtek/rtl8366rb.c           | 390 ++++++++---------
  5 files changed, 669 insertions(+), 670 deletions(-)
  rename drivers/net/dsa/realtek/{realtek-smi-core.h => realtek.h} (56%)

diff --git a/drivers/net/dsa/realtek/realtek-smi-core.c b/drivers/net/dsa/realtek/realtek-smi-core.c
index aae46ada8d83..2c78eb5c0bdc 100644
--- a/drivers/net/dsa/realtek/realtek-smi-core.c
+++ b/drivers/net/dsa/realtek/realtek-smi-core.c

@@ -40,105 +40,105 @@
  #include <linux/bitops.h>
  #include <linux/if_bridge.h>
  
-#include "realtek-smi-core.h"
+#include "realtek.h"
  
  #define REALTEK_SMI_ACK_RETRY_COUNT		5
  #define REALTEK_SMI_HW_STOP_DELAY		25	/* msecs */
  #define REALTEK_SMI_HW_START_DELAY		100	/* msecs */
  
-static inline void realtek_smi_clk_delay(struct realtek_smi *smi)
+static inline void realtek_smi_clk_delay(struct realtek_priv *priv)
  {
-	ndelay(smi->clk_delay);
+	ndelay(priv->clk_delay);
  }
  
-static void realtek_smi_start(struct realtek_smi *smi)
+static void realtek_smi_start(struct realtek_priv *priv)
  {
  	/* Set GPIO pins to output mode, with initial state:
  	 * SCK = 0, SDA = 1
  	 */
-	gpiod_direction_output(smi->mdc, 0);
-	gpiod_direction_output(smi->mdio, 1);
-	realtek_smi_clk_delay(smi);
+	gpiod_direction_output(priv->mdc, 0);
+	gpiod_direction_output(priv->mdio, 1);
+	realtek_smi_clk_delay(priv);
  
  	/* CLK 1: 0 -> 1, 1 -> 0 */
-	gpiod_set_value(smi->mdc, 1);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 0);
-	realtek_smi_clk_delay(smi);
+	gpiod_set_value(priv->mdc, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 0);
+	realtek_smi_clk_delay(priv);
  
  	/* CLK 2: */
-	gpiod_set_value(smi->mdc, 1);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdio, 0);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 0);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdio, 1);
+	gpiod_set_value(priv->mdc, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdio, 0);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 0);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdio, 1);
  }
  
-static void realtek_smi_stop(struct realtek_smi *smi)
+static void realtek_smi_stop(struct realtek_priv *priv)
  {
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdio, 0);
-	gpiod_set_value(smi->mdc, 1);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdio, 1);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 1);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 0);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdio, 0);
+	gpiod_set_value(priv->mdc, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdio, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 0);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 1);
  
  	/* Add a click */
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 0);
-	realtek_smi_clk_delay(smi);
-	gpiod_set_value(smi->mdc, 1);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 0);
+	realtek_smi_clk_delay(priv);
+	gpiod_set_value(priv->mdc, 1);
  
  	/* Set GPIO pins to input mode */
-	gpiod_direction_input(smi->mdio);
-	gpiod_direction_input(smi->mdc);
+	gpiod_direction_input(priv->mdio);
+	gpiod_direction_input(priv->mdc);
  }
  
-static void realtek_smi_write_bits(struct realtek_smi *smi, u32 data, u32 len)
+static void realtek_smi_write_bits(struct realtek_priv *priv, u32 data, u32 len)
  {
  	for (; len > 0; len--) {
-		realtek_smi_clk_delay(smi);
+		realtek_smi_clk_delay(priv);
  
  		/* Prepare data */
-		gpiod_set_value(smi->mdio, !!(data & (1 << (len - 1))));
-		realtek_smi_clk_delay(smi);
+		gpiod_set_value(priv->mdio, !!(data & (1 << (len - 1))));
+		realtek_smi_clk_delay(priv);
  
  		/* Clocking */
-		gpiod_set_value(smi->mdc, 1);
-		realtek_smi_clk_delay(smi);
-		gpiod_set_value(smi->mdc, 0);
+		gpiod_set_value(priv->mdc, 1);
+		realtek_smi_clk_delay(priv);
+		gpiod_set_value(priv->mdc, 0);
  	}
  }
  
-static void realtek_smi_read_bits(struct realtek_smi *smi, u32 len, u32 *data)
+static void realtek_smi_read_bits(struct realtek_priv *priv, u32 len, u32 *data)
  {
-	gpiod_direction_input(smi->mdio);
+	gpiod_direction_input(priv->mdio);
  
  	for (*data = 0; len > 0; len--) {
  		u32 u;
  
-		realtek_smi_clk_delay(smi);
+		realtek_smi_clk_delay(priv);
  
  		/* Clocking */
-		gpiod_set_value(smi->mdc, 1);
-		realtek_smi_clk_delay(smi);
-		u = !!gpiod_get_value(smi->mdio);
-		gpiod_set_value(smi->mdc, 0);
+		gpiod_set_value(priv->mdc, 1);
+		realtek_smi_clk_delay(priv);
+		u = !!gpiod_get_value(priv->mdio);
+		gpiod_set_value(priv->mdc, 0);
  
  		*data |= (u << (len - 1));
  	}
  
-	gpiod_direction_output(smi->mdio, 0);
+	gpiod_direction_output(priv->mdio, 0);
  }
  
-static int realtek_smi_wait_for_ack(struct realtek_smi *smi)
+static int realtek_smi_wait_for_ack(struct realtek_priv *priv)
  {
  	int retry_cnt;
  

@@ -146,12 +146,12 @@ static int realtek_smi_wait_for_ack(struct realtek_smi *smi)
  	do {
  		u32 ack;
  
-		realtek_smi_read_bits(smi, 1, &ack);
+		realtek_smi_read_bits(priv, 1, &ack);
  		if (ack == 0)
  			break;
  
  		if (++retry_cnt > REALTEK_SMI_ACK_RETRY_COUNT) {
-			dev_err(smi->dev, "ACK timeout\n");
+			dev_err(priv->dev, "ACK timeout\n");
  			return -ETIMEDOUT;
  		}
  	} while (1);

@@ -159,131 +159,131 @@ static int realtek_smi_wait_for_ack(struct realtek_smi *smi)
  	return 0;
  }
  
-static int realtek_smi_write_byte(struct realtek_smi *smi, u8 data)
+static int realtek_smi_write_byte(struct realtek_priv *priv, u8 data)
  {
-	realtek_smi_write_bits(smi, data, 8);
-	return realtek_smi_wait_for_ack(smi);
+	realtek_smi_write_bits(priv, data, 8);
+	return realtek_smi_wait_for_ack(priv);
  }
  
-static int realtek_smi_write_byte_noack(struct realtek_smi *smi, u8 data)
+static int realtek_smi_write_byte_noack(struct realtek_priv *priv, u8 data)
  {
-	realtek_smi_write_bits(smi, data, 8);
+	realtek_smi_write_bits(priv, data, 8);
  	return 0;
  }
  
-static int realtek_smi_read_byte0(struct realtek_smi *smi, u8 *data)
+static int realtek_smi_read_byte0(struct realtek_priv *priv, u8 *data)
  {
  	u32 t;
  
  	/* Read data */
-	realtek_smi_read_bits(smi, 8, &t);
+	realtek_smi_read_bits(priv, 8, &t);
  	*data = (t & 0xff);
  
  	/* Send an ACK */
-	realtek_smi_write_bits(smi, 0x00, 1);
+	realtek_smi_write_bits(priv, 0x00, 1);
  
  	return 0;
  }
  
-static int realtek_smi_read_byte1(struct realtek_smi *smi, u8 *data)
+static int realtek_smi_read_byte1(struct realtek_priv *priv, u8 *data)
  {
  	u32 t;
  
  	/* Read data */
-	realtek_smi_read_bits(smi, 8, &t);
+	realtek_smi_read_bits(priv, 8, &t);
  	*data = (t & 0xff);
  
  	/* Send an ACK */
-	realtek_smi_write_bits(smi, 0x01, 1);
+	realtek_smi_write_bits(priv, 0x01, 1);
  
  	return 0;
  }
  
-static int realtek_smi_read_reg(struct realtek_smi *smi, u32 addr, u32 *data)
+static int realtek_smi_read_reg(struct realtek_priv *priv, u32 addr, u32 *data)
  {
  	unsigned long flags;
  	u8 lo = 0;
  	u8 hi = 0;
  	int ret;
  
-	spin_lock_irqsave(&smi->lock, flags);
+	spin_lock_irqsave(&priv->lock, flags);
  
-	realtek_smi_start(smi);
+	realtek_smi_start(priv);
  
  	/* Send READ command */
-	ret = realtek_smi_write_byte(smi, smi->cmd_read);
+	ret = realtek_smi_write_byte(priv, priv->cmd_read);
  	if (ret)
  		goto out;
  
  	/* Set ADDR[7:0] */
-	ret = realtek_smi_write_byte(smi, addr & 0xff);
+	ret = realtek_smi_write_byte(priv, addr & 0xff);
  	if (ret)
  		goto out;
  
  	/* Set ADDR[15:8] */
-	ret = realtek_smi_write_byte(smi, addr >> 8);
+	ret = realtek_smi_write_byte(priv, addr >> 8);
  	if (ret)
  		goto out;
  
  	/* Read DATA[7:0] */
-	realtek_smi_read_byte0(smi, &lo);
+	realtek_smi_read_byte0(priv, &lo);
  	/* Read DATA[15:8] */
-	realtek_smi_read_byte1(smi, &hi);
+	realtek_smi_read_byte1(priv, &hi);
  
  	*data = ((u32)lo) | (((u32)hi) << 8);
  
  	ret = 0;
  
   out:
-	realtek_smi_stop(smi);
-	spin_unlock_irqrestore(&smi->lock, flags);
+	realtek_smi_stop(priv);
+	spin_unlock_irqrestore(&priv->lock, flags);
  
  	return ret;
  }
  
-static int realtek_smi_write_reg(struct realtek_smi *smi,
+static int realtek_smi_write_reg(struct realtek_priv *priv,
  				 u32 addr, u32 data, bool ack)
  {
  	unsigned long flags;
  	int ret;
  
-	spin_lock_irqsave(&smi->lock, flags);
+	spin_lock_irqsave(&priv->lock, flags);
  
-	realtek_smi_start(smi);
+	realtek_smi_start(priv);
  
  	/* Send WRITE command */
-	ret = realtek_smi_write_byte(smi, smi->cmd_write);
+	ret = realtek_smi_write_byte(priv, priv->cmd_write);
  	if (ret)
  		goto out;
  
  	/* Set ADDR[7:0] */
-	ret = realtek_smi_write_byte(smi, addr & 0xff);
+	ret = realtek_smi_write_byte(priv, addr & 0xff);
  	if (ret)
  		goto out;
  
  	/* Set ADDR[15:8] */
-	ret = realtek_smi_write_byte(smi, addr >> 8);
+	ret = realtek_smi_write_byte(priv, addr >> 8);
  	if (ret)
  		goto out;
  
  	/* Write DATA[7:0] */
-	ret = realtek_smi_write_byte(smi, data & 0xff);
+	ret = realtek_smi_write_byte(priv, data & 0xff);
  	if (ret)
  		goto out;
  
  	/* Write DATA[15:8] */
  	if (ack)
-		ret = realtek_smi_write_byte(smi, data >> 8);
+		ret = realtek_smi_write_byte(priv, data >> 8);
  	else
-		ret = realtek_smi_write_byte_noack(smi, data >> 8);
+		ret = realtek_smi_write_byte_noack(priv, data >> 8);
  	if (ret)
  		goto out;
  
  	ret = 0;
  
   out:
-	realtek_smi_stop(smi);
-	spin_unlock_irqrestore(&smi->lock, flags);
+	realtek_smi_stop(priv);
+	spin_unlock_irqrestore(&priv->lock, flags);
  
  	return ret;
  }

@@ -292,10 +292,10 @@ static int realtek_smi_write_reg(struct realtek_smi *smi,
   * is when issueing soft reset. Since the device reset as soon as we write
   * that bit, no ACK will come back for natural reasons.
   */
-int realtek_smi_write_reg_noack(struct realtek_smi *smi, u32 addr,
+int realtek_smi_write_reg_noack(struct realtek_priv *priv, u32 addr,
  				u32 data)
  {
-	return realtek_smi_write_reg(smi, addr, data, false);
+	return realtek_smi_write_reg(priv, addr, data, false);
  }
  EXPORT_SYMBOL_GPL(realtek_smi_write_reg_noack);

@@ -303,16 +303,16 @@ EXPORT_SYMBOL_GPL(realtek_smi_write_reg_noack);
  
  static int realtek_smi_write(void *ctx, u32 reg, u32 val)
  {
-	struct realtek_smi *smi = ctx;
+	struct realtek_priv *priv = ctx;
  
-	return realtek_smi_write_reg(smi, reg, val, true);
+	return realtek_smi_write_reg(priv, reg, val, true);
  }
  
  static int realtek_smi_read(void *ctx, u32 reg, u32 *val)
  {
-	struct realtek_smi *smi = ctx;
+	struct realtek_priv *priv = ctx;
  
-	return realtek_smi_read_reg(smi, reg, val);
+	return realtek_smi_read_reg(priv, reg, val);
  }
  
  static const struct regmap_config realtek_smi_mdio_regmap_config = {

@@ -329,49 +329,49 @@ static const struct regmap_config realtek_smi_mdio_regmap_config = {
  
  static int realtek_smi_mdio_read(struct mii_bus *bus, int addr, int regnum)
  {
-	struct realtek_smi *smi = bus->priv;
+	struct realtek_priv *priv = bus->priv;
  
-	return smi->ops->phy_read(smi, addr, regnum);
+	return priv->ops->phy_read(priv, addr, regnum);
  }
  
  static int realtek_smi_mdio_write(struct mii_bus *bus, int addr, int regnum,
  				  u16 val)
  {
-	struct realtek_smi *smi = bus->priv;
+	struct realtek_priv *priv = bus->priv;
  
-	return smi->ops->phy_write(smi, addr, regnum, val);
+	return priv->ops->phy_write(priv, addr, regnum, val);
  }
  
-int realtek_smi_setup_mdio(struct realtek_smi *smi)
+int realtek_smi_setup_mdio(struct realtek_priv *priv)
  {
  	struct device_node *mdio_np;
  	int ret;
  
-	mdio_np = of_get_compatible_child(smi->dev->of_node, "realtek,smi-mdio");
+	mdio_np = of_get_compatible_child(priv->dev->of_node, "realtek,smi-mdio");
  	if (!mdio_np) {
-		dev_err(smi->dev, "no MDIO bus node\n");
+		dev_err(priv->dev, "no MDIO bus node\n");
  		return -ENODEV;
  	}
  
-	smi->slave_mii_bus = devm_mdiobus_alloc(smi->dev);
-	if (!smi->slave_mii_bus) {
+	priv->slave_mii_bus = devm_mdiobus_alloc(priv->dev);
+	if (!priv->slave_mii_bus) {
  		ret = -ENOMEM;
  		goto err_put_node;
  	}
-	smi->slave_mii_bus->priv = smi;
-	smi->slave_mii_bus->name = "SMI slave MII";
-	smi->slave_mii_bus->read = realtek_smi_mdio_read;
-	smi->slave_mii_bus->write = realtek_smi_mdio_write;
-	snprintf(smi->slave_mii_bus->id, MII_BUS_ID_SIZE, "SMI-%d",
-		 smi->ds->index);
-	smi->slave_mii_bus->dev.of_node = mdio_np;
-	smi->slave_mii_bus->parent = smi->dev;
-	smi->ds->slave_mii_bus = smi->slave_mii_bus;
-
-	ret = devm_of_mdiobus_register(smi->dev, smi->slave_mii_bus, mdio_np);
+	priv->slave_mii_bus->priv = priv;
+	priv->slave_mii_bus->name = "SMI slave MII";
+	priv->slave_mii_bus->read = realtek_smi_mdio_read;
+	priv->slave_mii_bus->write = realtek_smi_mdio_write;
+	snprintf(priv->slave_mii_bus->id, MII_BUS_ID_SIZE, "SMI-%d",
+		 priv->ds->index);
+	priv->slave_mii_bus->dev.of_node = mdio_np;
+	priv->slave_mii_bus->parent = priv->dev;
+	priv->ds->slave_mii_bus = priv->slave_mii_bus;
+
+	ret = devm_of_mdiobus_register(priv->dev, priv->slave_mii_bus, mdio_np);
  	if (ret) {
-		dev_err(smi->dev, "unable to register MDIO bus %s\n",
-			smi->slave_mii_bus->id);
+		dev_err(priv->dev, "unable to register MDIO bus %s\n",
+			priv->slave_mii_bus->id);
  		goto err_put_node;
  	}
  

@@ -385,76 +385,76 @@ int realtek_smi_setup_mdio(struct realtek_smi *smi)
  
  static int realtek_smi_probe(struct platform_device *pdev)
  {
-	const struct realtek_smi_variant *var;
+	const struct realtek_variant *var;
  	struct device *dev = &pdev->dev;
-	struct realtek_smi *smi;
+	struct realtek_priv *priv;
  	struct device_node *np;
  	int ret;
  
  	var = of_device_get_match_data(dev);
  	np = dev->of_node;
  
-	smi = devm_kzalloc(dev, sizeof(*smi) + var->chip_data_sz, GFP_KERNEL);
-	if (!smi)
+	priv = devm_kzalloc(dev, sizeof(*priv) + var->chip_data_sz, GFP_KERNEL);
+	if (!priv)
  		return -ENOMEM;
-	smi->chip_data = (void *)smi + sizeof(*smi);
-	smi->map = devm_regmap_init(dev, NULL, smi,
+	priv->chip_data = (void *)priv + sizeof(*priv);
+	priv->map = devm_regmap_init(dev, NULL, priv,
  				    &realtek_smi_mdio_regmap_config);
-	if (IS_ERR(smi->map)) {
-		ret = PTR_ERR(smi->map);
+	if (IS_ERR(priv->map)) {
+		ret = PTR_ERR(priv->map);
  		dev_err(dev, "regmap init failed: %d\n", ret);
  		return ret;
  	}
  
  	/* Link forward and backward */
-	smi->dev = dev;
-	smi->clk_delay = var->clk_delay;
-	smi->cmd_read = var->cmd_read;
-	smi->cmd_write = var->cmd_write;
-	smi->ops = var->ops;
+	priv->dev = dev;
+	priv->clk_delay = var->clk_delay;
+	priv->cmd_read = var->cmd_read;
+	priv->cmd_write = var->cmd_write;
+	priv->ops = var->ops;
  
-	dev_set_drvdata(dev, smi);
-	spin_lock_init(&smi->lock);
+	dev_set_drvdata(dev, priv);
+	spin_lock_init(&priv->lock);
  
  	/* TODO: if power is software controlled, set up any regulators here */
  
  	/* Assert then deassert RESET */
-	smi->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
-	if (IS_ERR(smi->reset)) {
+	priv->reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+	if (IS_ERR(priv->reset)) {
  		dev_err(dev, "failed to get RESET GPIO\n");
-		return PTR_ERR(smi->reset);
+		return PTR_ERR(priv->reset);
  	}
  	msleep(REALTEK_SMI_HW_STOP_DELAY);
-	gpiod_set_value(smi->reset, 0);
+	gpiod_set_value(priv->reset, 0);
  	msleep(REALTEK_SMI_HW_START_DELAY);
  	dev_info(dev, "deasserted RESET\n");
  
  	/* Fetch MDIO pins */
-	smi->mdc = devm_gpiod_get_optional(dev, "mdc", GPIOD_OUT_LOW);
-	if (IS_ERR(smi->mdc))
-		return PTR_ERR(smi->mdc);
-	smi->mdio = devm_gpiod_get_optional(dev, "mdio", GPIOD_OUT_LOW);
-	if (IS_ERR(smi->mdio))
-		return PTR_ERR(smi->mdio);
+	priv->mdc = devm_gpiod_get_optional(dev, "mdc", GPIOD_OUT_LOW);
+	if (IS_ERR(priv->mdc))
+		return PTR_ERR(priv->mdc);
+	priv->mdio = devm_gpiod_get_optional(dev, "mdio", GPIOD_OUT_LOW);
+	if (IS_ERR(priv->mdio))
+		return PTR_ERR(priv->mdio);
  
-	smi->leds_disabled = of_property_read_bool(np, "realtek,disable-leds");
+	priv->leds_disabled = of_property_read_bool(np, "realtek,disable-leds");
  
-	ret = smi->ops->detect(smi);
+	ret = priv->ops->detect(priv);
  	if (ret) {
  		dev_err(dev, "unable to detect switch\n");
  		return ret;
  	}
  
-	smi->ds = devm_kzalloc(dev, sizeof(*smi->ds), GFP_KERNEL);
-	if (!smi->ds)
+	priv->ds = devm_kzalloc(dev, sizeof(*priv->ds), GFP_KERNEL);
+	if (!priv->ds)
  		return -ENOMEM;
  
-	smi->ds->dev = dev;
-	smi->ds->num_ports = smi->num_ports;
-	smi->ds->priv = smi;
+	priv->ds->dev = dev;
+	priv->ds->num_ports = priv->num_ports;
+	priv->ds->priv = priv;
  
-	smi->ds->ops = var->ds_ops;
-	ret = dsa_register_switch(smi->ds);
+	priv->ds->ops = var->ds_ops;
+	ret = dsa_register_switch(priv->ds);
  	if (ret) {
  		dev_err_probe(dev, ret, "unable to register switch\n");
  		return ret;

@@ -464,15 +464,15 @@ static int realtek_smi_probe(struct platform_device *pdev)
  
  static int realtek_smi_remove(struct platform_device *pdev)
  {
-	struct realtek_smi *smi = platform_get_drvdata(pdev);
+	struct realtek_priv *priv = platform_get_drvdata(pdev);
  
-	if (!smi)
+	if (!priv)
  		return 0;
  
-	dsa_unregister_switch(smi->ds);
-	if (smi->slave_mii_bus)
-		of_node_put(smi->slave_mii_bus->dev.of_node);
-	gpiod_set_value(smi->reset, 1);
+	dsa_unregister_switch(priv->ds);
+	if (priv->slave_mii_bus)
+		of_node_put(priv->slave_mii_bus->dev.of_node);
+	gpiod_set_value(priv->reset, 1);
  
  	platform_set_drvdata(pdev, NULL);
  

@@ -481,12 +481,12 @@ static int realtek_smi_remove(struct platform_device *pdev)
  
  static void realtek_smi_shutdown(struct platform_device *pdev)
  {
-	struct realtek_smi *smi = platform_get_drvdata(pdev);
+	struct realtek_priv *priv = platform_get_drvdata(pdev);
  
-	if (!smi)
+	if (!priv)
  		return;
  
-	dsa_switch_shutdown(smi->ds);
+	dsa_switch_shutdown(priv->ds);
  
  	platform_set_drvdata(pdev, NULL);
  }

diff --git a/drivers/net/dsa/realtek/realtek-smi-core.h b/drivers/net/dsa/realtek/realtek.h
similarity index 56%
rename from drivers/net/dsa/realtek/realtek-smi-core.h
rename to drivers/net/dsa/realtek/realtek.h
index 5bfa53e2480a..766e79151a6c 100644
--- a/drivers/net/dsa/realtek/realtek-smi-core.h
+++ b/drivers/net/dsa/realtek/realtek.h

@@ -13,7 +13,7 @@
  #include <linux/gpio/consumer.h>
  #include <net/dsa.h>
  
-struct realtek_smi_ops;
+struct realtek_ops;
  struct dentry;
  struct inode;
  struct file;

@@ -43,7 +43,7 @@ struct rtl8366_vlan_4k {
  	u8	fid;
  };
  
-struct realtek_smi {
+struct realtek_priv {
  	struct device		*dev;
  	struct gpio_desc	*reset;
  	struct gpio_desc	*mdc;

@@ -65,7 +65,9 @@ struct realtek_smi {
  	unsigned int		num_mib_counters;
  	struct rtl8366_mib_counter *mib_counters;
  
-	const struct realtek_smi_ops *ops;
+	const struct realtek_ops *ops;
+	int 		 	(*setup_interface)(struct dsa_switch *ds);
+	int 			(*write_reg_noack)(struct realtek_priv *priv, u32 addr, u32 data);
  
  	int			vlan_enabled;
  	int			vlan4k_enabled;

@@ -75,60 +77,55 @@ struct realtek_smi {
  };
  
  /**
- * struct realtek_smi_ops - vtable for the per-SMI-chiptype operations
+ * struct realtek_ops - vtable for the per-SMI-chiptype operations
   * @detect: detects the chiptype
   */
-struct realtek_smi_ops {
-	int	(*detect)(struct realtek_smi *smi);
-	int	(*reset_chip)(struct realtek_smi *smi);
-	int	(*setup)(struct realtek_smi *smi);
-	void	(*cleanup)(struct realtek_smi *smi);
-	int	(*get_mib_counter)(struct realtek_smi *smi,
+struct realtek_ops {
+	int	(*detect)(struct realtek_priv *priv);
+	int	(*reset_chip)(struct realtek_priv *priv);
+	int	(*setup)(struct realtek_priv *priv);
+	void	(*cleanup)(struct realtek_priv *priv);
+	int	(*get_mib_counter)(struct realtek_priv *priv,
  				   int port,
  				   struct rtl8366_mib_counter *mib,
  				   u64 *mibvalue);
-	int	(*get_vlan_mc)(struct realtek_smi *smi, u32 index,
+	int	(*get_vlan_mc)(struct realtek_priv *priv, u32 index,
  			       struct rtl8366_vlan_mc *vlanmc);
-	int	(*set_vlan_mc)(struct realtek_smi *smi, u32 index,
+	int	(*set_vlan_mc)(struct realtek_priv *priv, u32 index,
  			       const struct rtl8366_vlan_mc *vlanmc);
-	int	(*get_vlan_4k)(struct realtek_smi *smi, u32 vid,
+	int	(*get_vlan_4k)(struct realtek_priv *priv, u32 vid,
  			       struct rtl8366_vlan_4k *vlan4k);
-	int	(*set_vlan_4k)(struct realtek_smi *smi,
+	int	(*set_vlan_4k)(struct realtek_priv *priv,
  			       const struct rtl8366_vlan_4k *vlan4k);
-	int	(*get_mc_index)(struct realtek_smi *smi, int port, int *val);
-	int	(*set_mc_index)(struct realtek_smi *smi, int port, int index);
-	bool	(*is_vlan_valid)(struct realtek_smi *smi, unsigned int vlan);
-	int	(*enable_vlan)(struct realtek_smi *smi, bool enable);
-	int	(*enable_vlan4k)(struct realtek_smi *smi, bool enable);
-	int	(*enable_port)(struct realtek_smi *smi, int port, bool enable);
-	int	(*phy_read)(struct realtek_smi *smi, int phy, int regnum);
-	int	(*phy_write)(struct realtek_smi *smi, int phy, int regnum,
+	int	(*get_mc_index)(struct realtek_priv *priv, int port, int *val);
+	int	(*set_mc_index)(struct realtek_priv *priv, int port, int index);
+	bool	(*is_vlan_valid)(struct realtek_priv *priv, unsigned int vlan);
+	int	(*enable_vlan)(struct realtek_priv *priv, bool enable);
+	int	(*enable_vlan4k)(struct realtek_priv *priv, bool enable);
+	int	(*enable_port)(struct realtek_priv *priv, int port, bool enable);
+	int	(*phy_read)(struct realtek_priv *priv, int phy, int regnum);
+	int	(*phy_write)(struct realtek_priv *priv, int phy, int regnum,
  			     u16 val);
  };
  
-struct realtek_smi_variant {
+struct realtek_variant {
  	const struct dsa_switch_ops *ds_ops;
-	const struct realtek_smi_ops *ops;
+	const struct realtek_ops *ops;
  	unsigned int clk_delay;
  	u8 cmd_read;
  	u8 cmd_write;
  	size_t chip_data_sz;
  };
  
-/* SMI core calls */
-int realtek_smi_write_reg_noack(struct realtek_smi *smi, u32 addr,
-				u32 data);
-int realtek_smi_setup_mdio(struct realtek_smi *smi);
-
  /* RTL8366 library helpers */
-int rtl8366_mc_is_used(struct realtek_smi *smi, int mc_index, int *used);
-int rtl8366_set_vlan(struct realtek_smi *smi, int vid, u32 member,
+int rtl8366_mc_is_used(struct realtek_priv *priv, int mc_index, int *used);
+int rtl8366_set_vlan(struct realtek_priv *priv, int vid, u32 member,
  		     u32 untag, u32 fid);
-int rtl8366_set_pvid(struct realtek_smi *smi, unsigned int port,
+int rtl8366_set_pvid(struct realtek_priv *priv, unsigned int port,
  		     unsigned int vid);
-int rtl8366_enable_vlan4k(struct realtek_smi *smi, bool enable);
-int rtl8366_enable_vlan(struct realtek_smi *smi, bool enable);
-int rtl8366_reset_vlan(struct realtek_smi *smi);
+int rtl8366_enable_vlan4k(struct realtek_priv *priv, bool enable);
+int rtl8366_enable_vlan(struct realtek_priv *priv, bool enable);
+int rtl8366_reset_vlan(struct realtek_priv *priv);
  int rtl8366_vlan_add(struct dsa_switch *ds, int port,
  		     const struct switchdev_obj_port_vlan *vlan,
  		     struct netlink_ext_ack *extack);

@@ -139,7 +136,7 @@ void rtl8366_get_strings(struct dsa_switch *ds, int port, u32 stringset,
  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_smi_variant rtl8366rb_variant;
-extern const struct realtek_smi_variant rtl8365mb_variant;
+extern const struct realtek_variant rtl8366rb_variant;
+extern const struct realtek_variant rtl8365mb_variant;
  
  #endif /*  _REALTEK_SMI_H */

diff --git a/drivers/net/dsa/realtek/rtl8365mb.c b/drivers/net/dsa/realtek/rtl8365mb.c
index 3b729544798b..f562a6efb574 100644
--- a/drivers/net/dsa/realtek/rtl8365mb.c
+++ b/drivers/net/dsa/realtek/rtl8365mb.c

@@ -99,7 +99,7 @@
  #include <linux/regmap.h>
  #include <linux/if_bridge.h>
  
-#include "realtek-smi-core.h"
+#include "realtek.h"
  
  /* Chip-specific data and limits */
  #define RTL8365MB_CHIP_ID_8365MB_VC		0x6367

@@ -516,7 +516,7 @@ struct rtl8365mb_cpu {
  
  /**
   * struct rtl8365mb_port - private per-port data
- * @smi: pointer to parent realtek_smi 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

@@ -524,7 +524,7 @@ struct rtl8365mb_cpu {
   * @mib_work: delayed work for polling MIB counters
   */
  struct rtl8365mb_port {
-	struct realtek_smi *smi;
+	struct realtek_priv *priv;
  	unsigned int index;
  	struct rtnl_link_stats64 stats;
  	spinlock_t stats_lock;

@@ -533,7 +533,7 @@ struct rtl8365mb_port {
  
  /**
   * struct rtl8365mb - private chip-specific driver data
- * @smi: pointer to parent realtek_smi data
+ * @priv: pointer to parent realtek_priv data
   * @irq: registered IRQ or zero
   * @chip_id: chip identifier
   * @chip_ver: chip silicon revision

@@ -548,7 +548,7 @@ struct rtl8365mb_port {
   * Private data for this driver.
   */
  struct rtl8365mb {
-	struct realtek_smi *smi;
+	struct realtek_priv *priv;
  	int irq;
  	u32 chip_id;
  	u32 chip_ver;

@@ -561,16 +561,16 @@ struct rtl8365mb {
  	size_t jam_size;
  };
  
-static int rtl8365mb_phy_poll_busy(struct realtek_smi *smi)
+static int rtl8365mb_phy_poll_busy(struct realtek_priv *priv)
  {
  	u32 val;
  
-	return regmap_read_poll_timeout(smi->map,
+	return regmap_read_poll_timeout(priv->map,
  					RTL8365MB_INDIRECT_ACCESS_STATUS_REG,
  					val, !val, 10, 100);
  }
  
-static int rtl8365mb_phy_ocp_prepare(struct realtek_smi *smi, int phy,
+static int rtl8365mb_phy_ocp_prepare(struct realtek_priv *priv, int phy,
  				     u32 ocp_addr)
  {
  	u32 val;

@@ -579,7 +579,7 @@ static int rtl8365mb_phy_ocp_prepare(struct realtek_smi *smi, int phy,
  	/* Set OCP prefix */
  	val = FIELD_GET(RTL8365MB_PHY_OCP_ADDR_PREFIX_MASK, ocp_addr);
  	ret = regmap_update_bits(
-		smi->map, RTL8365MB_GPHY_OCP_MSB_0_REG,
+		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));
  	if (ret)

@@ -592,7 +592,7 @@ static int rtl8365mb_phy_ocp_prepare(struct realtek_smi *smi, int phy,
  			  ocp_addr >> 1);
  	val |= FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_9_6_MASK,
  			  ocp_addr >> 6);
-	ret = regmap_write(smi->map, RTL8365MB_INDIRECT_ACCESS_ADDRESS_REG,
+	ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_ADDRESS_REG,
  			   val);
  	if (ret)
  		return ret;

@@ -600,17 +600,17 @@ static int rtl8365mb_phy_ocp_prepare(struct realtek_smi *smi, int phy,
  	return 0;
  }
  
-static int rtl8365mb_phy_ocp_read(struct realtek_smi *smi, int phy,
+static int rtl8365mb_phy_ocp_read(struct realtek_priv *priv, int phy,
  				  u32 ocp_addr, u16 *data)
  {
  	u32 val;
  	int ret;
  
-	ret = rtl8365mb_phy_poll_busy(smi);
+	ret = rtl8365mb_phy_poll_busy(priv);
  	if (ret)
  		return ret;
  
-	ret = rtl8365mb_phy_ocp_prepare(smi, phy, ocp_addr);
+	ret = rtl8365mb_phy_ocp_prepare(priv, phy, ocp_addr);
  	if (ret)
  		return ret;
  

@@ -619,16 +619,16 @@ static int rtl8365mb_phy_ocp_read(struct realtek_smi *smi, int phy,
  			 RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_VALUE) |
  	      FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_CTRL_RW_MASK,
  			 RTL8365MB_INDIRECT_ACCESS_CTRL_RW_READ);
-	ret = regmap_write(smi->map, RTL8365MB_INDIRECT_ACCESS_CTRL_REG, val);
+	ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_CTRL_REG, val);
  	if (ret)
  		return ret;
  
-	ret = rtl8365mb_phy_poll_busy(smi);
+	ret = rtl8365mb_phy_poll_busy(priv);
  	if (ret)
  		return ret;
  
  	/* Get PHY register data */
-	ret = regmap_read(smi->map, RTL8365MB_INDIRECT_ACCESS_READ_DATA_REG,
+	ret = regmap_read(priv->map, RTL8365MB_INDIRECT_ACCESS_READ_DATA_REG,
  			  &val);
  	if (ret)
  		return ret;

@@ -638,22 +638,22 @@ static int rtl8365mb_phy_ocp_read(struct realtek_smi *smi, int phy,
  	return 0;
  }
  
-static int rtl8365mb_phy_ocp_write(struct realtek_smi *smi, int phy,
+static int rtl8365mb_phy_ocp_write(struct realtek_priv *priv, int phy,
  				   u32 ocp_addr, u16 data)
  {
  	u32 val;
  	int ret;
  
-	ret = rtl8365mb_phy_poll_busy(smi);
+	ret = rtl8365mb_phy_poll_busy(priv);
  	if (ret)
  		return ret;
  
-	ret = rtl8365mb_phy_ocp_prepare(smi, phy, ocp_addr);
+	ret = rtl8365mb_phy_ocp_prepare(priv, phy, ocp_addr);
  	if (ret)
  		return ret;
  
  	/* Set PHY register data */
-	ret = regmap_write(smi->map, RTL8365MB_INDIRECT_ACCESS_WRITE_DATA_REG,
+	ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_WRITE_DATA_REG,
  			   data);
  	if (ret)
  		return ret;

@@ -663,18 +663,18 @@ static int rtl8365mb_phy_ocp_write(struct realtek_smi *smi, int phy,
  			 RTL8365MB_INDIRECT_ACCESS_CTRL_CMD_VALUE) |
  	      FIELD_PREP(RTL8365MB_INDIRECT_ACCESS_CTRL_RW_MASK,
  			 RTL8365MB_INDIRECT_ACCESS_CTRL_RW_WRITE);
-	ret = regmap_write(smi->map, RTL8365MB_INDIRECT_ACCESS_CTRL_REG, val);
+	ret = regmap_write(priv->map, RTL8365MB_INDIRECT_ACCESS_CTRL_REG, val);
  	if (ret)
  		return ret;
  
-	ret = rtl8365mb_phy_poll_busy(smi);
+	ret = rtl8365mb_phy_poll_busy(priv);
  	if (ret)
  		return ret;
  
  	return 0;
  }
  
-static int rtl8365mb_phy_read(struct realtek_smi *smi, int phy, int regnum)
+static int rtl8365mb_phy_read(struct realtek_priv *priv, int phy, int regnum)
  {
  	u32 ocp_addr;
  	u16 val;

@@ -688,21 +688,21 @@ static int rtl8365mb_phy_read(struct realtek_smi *smi, int phy, int regnum)
  
  	ocp_addr = RTL8365MB_PHY_OCP_ADDR_PHYREG_BASE + regnum * 2;
  
-	ret = rtl8365mb_phy_ocp_read(smi, phy, ocp_addr, &val);
+	ret = rtl8365mb_phy_ocp_read(priv, phy, ocp_addr, &val);
  	if (ret) {
-		dev_err(smi->dev,
+		dev_err(priv->dev,
  			"failed to read PHY%d reg %02x @ %04x, ret %d\n", phy,
  			regnum, ocp_addr, ret);
  		return ret;
  	}
  
-	dev_dbg(smi->dev, "read PHY%d register 0x%02x @ %04x, val <- %04x\n",
+	dev_dbg(priv->dev, "read PHY%d register 0x%02x @ %04x, val <- %04x\n",
  		phy, regnum, ocp_addr, val);
  
  	return val;
  }
  
-static int rtl8365mb_phy_write(struct realtek_smi *smi, int phy, int regnum,
+static int rtl8365mb_phy_write(struct realtek_priv *priv, int phy, int regnum,
  			       u16 val)
  {
  	u32 ocp_addr;

@@ -716,15 +716,15 @@ static int rtl8365mb_phy_write(struct realtek_smi *smi, int phy, int regnum,
  
  	ocp_addr = RTL8365MB_PHY_OCP_ADDR_PHYREG_BASE + regnum * 2;
  
-	ret = rtl8365mb_phy_ocp_write(smi, phy, ocp_addr, val);
+	ret = rtl8365mb_phy_ocp_write(priv, phy, ocp_addr, val);
  	if (ret) {
-		dev_err(smi->dev,
+		dev_err(priv->dev,
  			"failed to write PHY%d reg %02x @ %04x, ret %d\n", phy,
  			regnum, ocp_addr, ret);
  		return ret;
  	}
  
-	dev_dbg(smi->dev, "write PHY%d register 0x%02x @ %04x, val -> %04x\n",
+	dev_dbg(priv->dev, "write PHY%d register 0x%02x @ %04x, val -> %04x\n",
  		phy, regnum, ocp_addr, val);
  
  	return 0;

@@ -737,7 +737,7 @@ rtl8365mb_get_tag_protocol(struct dsa_switch *ds, int port,
  	return DSA_TAG_PROTO_RTL8_4;
  }
  
-static int rtl8365mb_ext_config_rgmii(struct realtek_smi *smi, int port,
+static int rtl8365mb_ext_config_rgmii(struct realtek_priv *priv, int port,
  				      phy_interface_t interface)
  {
  	struct device_node *dn;

@@ -748,14 +748,14 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_smi *smi, int port,
  	u32 val;
  	int ret;
  
-	if (port == smi->cpu_port) {
+	if (port == priv->cpu_port) {
  		ext_port = 1;
  	} else {
-		dev_err(smi->dev, "only one EXT port is currently supported\n");
+		dev_err(priv->dev, "only one EXT port is currently supported\n");
  		return -EINVAL;
  	}
  
-	dp = dsa_to_port(smi->ds, port);
+	dp = dsa_to_port(priv->ds, port);
  	dn = dp->dn;
  
  	/* Set the RGMII TX/RX delay

@@ -786,7 +786,7 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_smi *smi, int port,
  		if (val == 0 || val == 2)
  			tx_delay = val / 2;
  		else
-			dev_warn(smi->dev,
+			dev_warn(priv->dev,
  				 "EXT port TX delay must be 0 or 2 ns\n");
  	}
  

@@ -796,12 +796,12 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_smi *smi, int port,
  		if (val <= 7)
  			rx_delay = val;
  		else
-			dev_warn(smi->dev,
+			dev_warn(priv->dev,
  				 "EXT port RX delay must be 0 to 2.1 ns\n");
  	}
  
  	ret = regmap_update_bits(
-		smi->map, RTL8365MB_EXT_RGMXF_REG(ext_port),
+		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) |

@@ -810,7 +810,7 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_smi *smi, int port,
  		return ret;
  
  	ret = regmap_update_bits(
-		smi->map, RTL8365MB_DIGITAL_INTERFACE_SELECT_REG(ext_port),
+		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(

@@ -821,7 +821,7 @@ static int rtl8365mb_ext_config_rgmii(struct realtek_smi *smi, int port,
  	return 0;
  }
  
-static int rtl8365mb_ext_config_forcemode(struct realtek_smi *smi, int port,
+static int rtl8365mb_ext_config_forcemode(struct realtek_priv *priv, int port,
  					  bool link, int speed, int duplex,
  					  bool tx_pause, bool rx_pause)
  {

@@ -834,10 +834,10 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_smi *smi, int port,
  	int val;
  	int ret;
  
-	if (port == smi->cpu_port) {
+	if (port == priv->cpu_port) {
  		ext_port = 1;
  	} else {
-		dev_err(smi->dev, "only one EXT port is currently supported\n");
+		dev_err(priv->dev, "only one EXT port is currently supported\n");
  		return -EINVAL;
  	}
  

@@ -854,7 +854,7 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_smi *smi, int port,
  		} else if (speed == SPEED_10) {
  			r_speed = RTL8365MB_PORT_SPEED_10M;
  		} else {
-			dev_err(smi->dev, "unsupported port speed %s\n",
+			dev_err(priv->dev, "unsupported port speed %s\n",
  				phy_speed_to_str(speed));
  			return -EINVAL;
  		}

@@ -864,7 +864,7 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_smi *smi, int port,
  		} else if (duplex == DUPLEX_HALF) {
  			r_duplex = 0;
  		} else {
-			dev_err(smi->dev, "unsupported duplex %s\n",
+			dev_err(priv->dev, "unsupported duplex %s\n",
  				phy_duplex_to_str(duplex));
  			return -EINVAL;
  		}

@@ -886,7 +886,7 @@ static int rtl8365mb_ext_config_forcemode(struct realtek_smi *smi, int port,
  	      FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_DUPLEX_MASK,
  			 r_duplex) |
  	      FIELD_PREP(RTL8365MB_DIGITAL_INTERFACE_FORCE_SPEED_MASK, r_speed);
-	ret = regmap_write(smi->map,
+	ret = regmap_write(priv->map,
  			   RTL8365MB_DIGITAL_INTERFACE_FORCE_REG(ext_port),
  			   val);
  	if (ret)

@@ -916,7 +916,7 @@ static void rtl8365mb_phylink_validate(struct dsa_switch *ds, int port,
  				       unsigned long *supported,
  				       struct phylink_link_state *state)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	__ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0 };
  
  	/* include/linux/phylink.h says:

@@ -925,7 +925,7 @@ static void rtl8365mb_phylink_validate(struct dsa_switch *ds, int port,
  	 */
  	if (state->interface != PHY_INTERFACE_MODE_NA &&
  	    !rtl8365mb_phy_mode_supported(ds, port, state->interface)) {
-		dev_err(smi->dev, "phy mode %s is unsupported on port %d\n",
+		dev_err(priv->dev, "phy mode %s is unsupported on port %d\n",
  			phy_modes(state->interface), port);
  		linkmode_zero(supported);
  		return;

@@ -951,26 +951,26 @@ static void rtl8365mb_phylink_mac_config(struct dsa_switch *ds, int port,
  					 unsigned int mode,
  					 const struct phylink_link_state *state)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	int ret;
  
  	if (!rtl8365mb_phy_mode_supported(ds, port, state->interface)) {
-		dev_err(smi->dev, "phy mode %s is unsupported on port %d\n",
+		dev_err(priv->dev, "phy mode %s is unsupported on port %d\n",
  			phy_modes(state->interface), port);
  		return;
  	}
  
  	if (mode != MLO_AN_PHY && mode != MLO_AN_FIXED) {
-		dev_err(smi->dev,
+		dev_err(priv->dev,
  			"port %d supports only conventional PHY or fixed-link\n",
  			port);
  		return;
  	}
  
  	if (phy_interface_mode_is_rgmii(state->interface)) {
-		ret = rtl8365mb_ext_config_rgmii(smi, port, state->interface);
+		ret = rtl8365mb_ext_config_rgmii(priv, port, state->interface);
  		if (ret)
-			dev_err(smi->dev,
+			dev_err(priv->dev,
  				"failed to configure RGMII mode on port %d: %d\n",
  				port, ret);
  		return;

@@ -985,20 +985,20 @@ static void rtl8365mb_phylink_mac_link_down(struct dsa_switch *ds, int port,
  					    unsigned int mode,
  					    phy_interface_t interface)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb_port *p;
  	struct rtl8365mb *mb;
  	int ret;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  	p = &mb->ports[port];
  	cancel_delayed_work_sync(&p->mib_work);
  
  	if (phy_interface_mode_is_rgmii(interface)) {
-		ret = rtl8365mb_ext_config_forcemode(smi, port, false, 0, 0,
+		ret = rtl8365mb_ext_config_forcemode(priv, port, false, 0, 0,
  						     false, false);
  		if (ret)
-			dev_err(smi->dev,
+			dev_err(priv->dev,
  				"failed to reset forced mode on port %d: %d\n",
  				port, ret);
  

@@ -1013,21 +1013,21 @@ static void rtl8365mb_phylink_mac_link_up(struct dsa_switch *ds, int port,
  					  int duplex, bool tx_pause,
  					  bool rx_pause)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb_port *p;
  	struct rtl8365mb *mb;
  	int ret;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  	p = &mb->ports[port];
  	schedule_delayed_work(&p->mib_work, 0);
  
  	if (phy_interface_mode_is_rgmii(interface)) {
-		ret = rtl8365mb_ext_config_forcemode(smi, port, true, speed,
+		ret = rtl8365mb_ext_config_forcemode(priv, port, true, speed,
  						     duplex, tx_pause,
  						     rx_pause);
  		if (ret)
-			dev_err(smi->dev,
+			dev_err(priv->dev,
  				"failed to force mode on port %d: %d\n", port,
  				ret);
  

@@ -1038,7 +1038,7 @@ 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,
  					 u8 state)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	enum rtl8365mb_stp_state val;
  	int msti = 0;
  

@@ -1057,36 +1057,36 @@ static void rtl8365mb_port_stp_state_set(struct dsa_switch *ds, int port,
  		val = RTL8365MB_STP_STATE_FORWARDING;
  		break;
  	default:
-		dev_err(smi->dev, "invalid STP state: %u\n", state);
+		dev_err(priv->dev, "invalid STP state: %u\n", state);
  		return;
  	}
  
-	regmap_update_bits(smi->map, RTL8365MB_MSTI_CTRL_REG(msti, port),
+	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));
  }
  
-static int rtl8365mb_port_set_learning(struct realtek_smi *smi, int port,
+static int rtl8365mb_port_set_learning(struct realtek_priv *priv, int port,
  				       bool enable)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *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(smi->map, RTL8365MB_LUT_PORT_LEARN_LIMIT_REG(port),
+	return regmap_write(priv->map, RTL8365MB_LUT_PORT_LEARN_LIMIT_REG(port),
  			    enable ? mb->learn_limit_max : 0);
  }
  
-static int rtl8365mb_port_set_isolation(struct realtek_smi *smi, int port,
+static int rtl8365mb_port_set_isolation(struct realtek_priv *priv, int port,
  					u32 mask)
  {
-	return regmap_write(smi->map, RTL8365MB_PORT_ISOLATION_REG(port), mask);
+	return regmap_write(priv->map, RTL8365MB_PORT_ISOLATION_REG(port), mask);
  }
  
-static int rtl8365mb_mib_counter_read(struct realtek_smi *smi, int port,
+static int rtl8365mb_mib_counter_read(struct realtek_priv *priv, int port,
  				      u32 offset, u32 length, u64 *mibvalue)
  {
  	u64 tmpvalue = 0;

@@ -1098,13 +1098,13 @@ static int rtl8365mb_mib_counter_read(struct realtek_smi *smi, int port,
  	 * and then poll the control register before reading the value from some
  	 * counter registers.
  	 */
-	ret = regmap_write(smi->map, RTL8365MB_MIB_ADDRESS_REG,
+	ret = regmap_write(priv->map, RTL8365MB_MIB_ADDRESS_REG,
  			   RTL8365MB_MIB_ADDRESS(port, offset));
  	if (ret)
  		return ret;
  
  	/* Poll for completion */
-	ret = regmap_read_poll_timeout(smi->map, RTL8365MB_MIB_CTRL0_REG, val,
+	ret = regmap_read_poll_timeout(priv->map, RTL8365MB_MIB_CTRL0_REG, val,
  				       !(val & RTL8365MB_MIB_CTRL0_BUSY_MASK),
  				       10, 100);
  	if (ret)

@@ -1126,7 +1126,7 @@ static int rtl8365mb_mib_counter_read(struct realtek_smi *smi, int port,
  
  	/* Read the MIB counter 16 bits at a time */
  	for (i = 0; i < length; i++) {
-		ret = regmap_read(smi->map,
+		ret = regmap_read(priv->map,
  				  RTL8365MB_MIB_COUNTER_REG(offset - i), &val);
  		if (ret)
  			return ret;

@@ -1142,21 +1142,21 @@ static int rtl8365mb_mib_counter_read(struct realtek_smi *smi, int port,
  
  static void rtl8365mb_get_ethtool_stats(struct dsa_switch *ds, int port, u64 *data)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb *mb;
  	int ret;
  	int i;
  
-	mb = smi->chip_data;
+	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];
  
-		ret = rtl8365mb_mib_counter_read(smi, port, mib->offset,
+		ret = rtl8365mb_mib_counter_read(priv, port, mib->offset,
  						 mib->length, &data[i]);
  		if (ret) {
-			dev_err(smi->dev,
+			dev_err(priv->dev,
  				"failed to read port %d counters: %d\n", port,
  				ret);
  			break;

@@ -1190,15 +1190,15 @@ static int rtl8365mb_get_sset_count(struct dsa_switch *ds, int port, int sset)
  static void rtl8365mb_get_phy_stats(struct dsa_switch *ds, int port,
  				    struct ethtool_eth_phy_stats *phy_stats)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb_mib_counter *mib;
  	struct rtl8365mb *mb;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  	mib = &rtl8365mb_mib_counters[RTL8365MB_MIB_dot3StatsSymbolErrors];
  
  	mutex_lock(&mb->mib_lock);
-	rtl8365mb_mib_counter_read(smi, port, mib->offset, mib->length,
+	rtl8365mb_mib_counter_read(priv, port, mib->offset, mib->length,
  				   &phy_stats->SymbolErrorDuringCarrier);
  	mutex_unlock(&mb->mib_lock);
  }

@@ -1226,12 +1226,12 @@ static void rtl8365mb_get_mac_stats(struct dsa_switch *ds, int port,
  		[RTL8365MB_MIB_dot3StatsExcessiveCollisions] = 1,
  
  	};
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb *mb;
  	int ret;
  	int i;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  
  	mutex_lock(&mb->mib_lock);
  	for (i = 0; i < RTL8365MB_MIB_END; i++) {

@@ -1241,7 +1241,7 @@ static void rtl8365mb_get_mac_stats(struct dsa_switch *ds, int port,
  		if (!cnt[i])
  			continue;
  
-		ret = rtl8365mb_mib_counter_read(smi, port, mib->offset,
+		ret = rtl8365mb_mib_counter_read(priv, port, mib->offset,
  						 mib->length, &cnt[i]);
  		if (ret)
  			break;

@@ -1291,20 +1291,20 @@ static void rtl8365mb_get_mac_stats(struct dsa_switch *ds, int port,
  static void rtl8365mb_get_ctrl_stats(struct dsa_switch *ds, int port,
  				     struct ethtool_eth_ctrl_stats *ctrl_stats)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb_mib_counter *mib;
  	struct rtl8365mb *mb;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  	mib = &rtl8365mb_mib_counters[RTL8365MB_MIB_dot3ControlInUnknownOpcodes];
  
  	mutex_lock(&mb->mib_lock);
-	rtl8365mb_mib_counter_read(smi, port, mib->offset, mib->length,
+	rtl8365mb_mib_counter_read(priv, port, mib->offset, mib->length,
  				   &ctrl_stats->UnsupportedOpcodesReceived);
  	mutex_unlock(&mb->mib_lock);
  }
  
-static void rtl8365mb_stats_update(struct realtek_smi *smi, int port)
+static void rtl8365mb_stats_update(struct realtek_priv *priv, int port)
  {
  	u64 cnt[RTL8365MB_MIB_END] = {
  		[RTL8365MB_MIB_ifOutOctets] = 1,

@@ -1323,7 +1323,7 @@ static void rtl8365mb_stats_update(struct realtek_smi *smi, int port)
  		[RTL8365MB_MIB_dot3StatsFCSErrors] = 1,
  		[RTL8365MB_MIB_dot3StatsLateCollisions] = 1,
  	};
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	struct rtnl_link_stats64 *stats;
  	int ret;
  	int i;

@@ -1338,7 +1338,7 @@ static void rtl8365mb_stats_update(struct realtek_smi *smi, int port)
  		if (!cnt[i])
  			continue;
  
-		ret = rtl8365mb_mib_counter_read(smi, port, c->offset,
+		ret = rtl8365mb_mib_counter_read(priv, port, c->offset,
  						 c->length, &cnt[i]);
  		if (ret)
  			break;

@@ -1388,9 +1388,9 @@ static void rtl8365mb_stats_poll(struct work_struct *work)
  	struct rtl8365mb_port *p = container_of(to_delayed_work(work),
  						struct rtl8365mb_port,
  						mib_work);
-	struct realtek_smi *smi = p->smi;
+	struct realtek_priv *priv = p->priv;
  
-	rtl8365mb_stats_update(smi, p->index);
+	rtl8365mb_stats_update(priv, p->index);
  
  	schedule_delayed_work(&p->mib_work, RTL8365MB_STATS_INTERVAL_JIFFIES);
  }

@@ -1398,11 +1398,11 @@ static void rtl8365mb_stats_poll(struct work_struct *work)
  static void rtl8365mb_get_stats64(struct dsa_switch *ds, int port,
  				  struct rtnl_link_stats64 *s)
  {
-	struct realtek_smi *smi = ds->priv;
+	struct realtek_priv *priv = ds->priv;
  	struct rtl8365mb_port *p;
  	struct rtl8365mb *mb;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  	p = &mb->ports[port];
  
  	spin_lock(&p->stats_lock);

@@ -1410,9 +1410,9 @@ static void rtl8365mb_get_stats64(struct dsa_switch *ds, int port,
  	spin_unlock(&p->stats_lock);
  }
  
-static void rtl8365mb_stats_setup(struct realtek_smi *smi)
+static void rtl8365mb_stats_setup(struct realtek_priv *priv)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	int i;
  
  	/* Per-chip global mutex to protect MIB counter access, since doing

@@ -1420,10 +1420,10 @@ static void rtl8365mb_stats_setup(struct realtek_smi *smi)
  	 */
  	mutex_init(&mb->mib_lock);
  
-	for (i = 0; i < smi->num_ports; i++) {
+	for (i = 0; i < priv->num_ports; i++) {
  		struct rtl8365mb_port *p = &mb->ports[i];
  
-		if (dsa_is_unused_port(smi->ds, i))
+		if (dsa_is_unused_port(priv->ds, i))
  			continue;
  
  		/* Per-port spinlock to protect the stats64 data */

@@ -1436,45 +1436,45 @@ static void rtl8365mb_stats_setup(struct realtek_smi *smi)
  	}
  }
  
-static void rtl8365mb_stats_teardown(struct realtek_smi *smi)
+static void rtl8365mb_stats_teardown(struct realtek_priv *priv)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	int i;
  
-	for (i = 0; i < smi->num_ports; i++) {
+	for (i = 0; i < priv->num_ports; i++) {
  		struct rtl8365mb_port *p = &mb->ports[i];
  
-		if (dsa_is_unused_port(smi->ds, i))
+		if (dsa_is_unused_port(priv->ds, i))
  			continue;
  
  		cancel_delayed_work_sync(&p->mib_work);
  	}
  }
  
-static int rtl8365mb_get_and_clear_status_reg(struct realtek_smi *smi, u32 reg,
+static int rtl8365mb_get_and_clear_status_reg(struct realtek_priv *priv, u32 reg,
  					      u32 *val)
  {
  	int ret;
  
-	ret = regmap_read(smi->map, reg, val);
+	ret = regmap_read(priv->map, reg, val);
  	if (ret)
  		return ret;
  
-	return regmap_write(smi->map, reg, *val);
+	return regmap_write(priv->map, reg, *val);
  }
  
  static irqreturn_t rtl8365mb_irq(int irq, void *data)
  {
-	struct realtek_smi *smi = data;
+	struct realtek_priv *priv = data;
  	unsigned long line_changes = 0;
  	struct rtl8365mb *mb;
  	u32 stat;
  	int line;
  	int ret;
  
-	mb = smi->chip_data;
+	mb = priv->chip_data;
  
-	ret = rtl8365mb_get_and_clear_status_reg(smi, RTL8365MB_INTR_STATUS_REG,
+	ret = rtl8365mb_get_and_clear_status_reg(priv, RTL8365MB_INTR_STATUS_REG,
  						 &stat);
  	if (ret)
  		goto out_error;

@@ -1485,14 +1485,14 @@ static irqreturn_t rtl8365mb_irq(int irq, void *data)
  		u32 val;
  
  		ret = rtl8365mb_get_and_clear_status_reg(
-			smi, RTL8365MB_PORT_LINKUP_IND_REG, &val);
+			priv, RTL8365MB_PORT_LINKUP_IND_REG, &val);
  		if (ret)
  			goto out_error;
  
  		linkup_ind = FIELD_GET(RTL8365MB_PORT_LINKUP_IND_MASK, val);
  
  		ret = rtl8365mb_get_and_clear_status_reg(
-			smi, RTL8365MB_PORT_LINKDOWN_IND_REG, &val);
+			priv, RTL8365MB_PORT_LINKDOWN_IND_REG, &val);
  		if (ret)
  			goto out_error;
  

@@ -1504,8 +1504,8 @@ static irqreturn_t rtl8365mb_irq(int irq, void *data)
  	if (!line_changes)
  		goto out_none;
  
-	for_each_set_bit(line, &line_changes, smi->num_ports) {
-		int child_irq = irq_find_mapping(smi->irqdomain, line);
+	for_each_set_bit(line, &line_changes, priv->num_ports) {
+		int child_irq = irq_find_mapping(priv->irqdomain, line);
  
  		handle_nested_irq(child_irq);
  	}

@@ -1513,7 +1513,7 @@ static irqreturn_t rtl8365mb_irq(int irq, void *data)
  	return IRQ_HANDLED;
  
  out_error:
-	dev_err(smi->dev, "failed to read interrupt status: %d\n", ret);
+	dev_err(priv->dev, "failed to read interrupt status: %d\n", ret);
  
  out_none:
  	return IRQ_NONE;

@@ -1548,27 +1548,27 @@ static const struct irq_domain_ops rtl8365mb_irqdomain_ops = {
  	.xlate = irq_domain_xlate_onecell,
  };
  
-static int rtl8365mb_set_irq_enable(struct realtek_smi *smi, bool enable)
+static int rtl8365mb_set_irq_enable(struct realtek_priv *priv, bool enable)
  {
-	return regmap_update_bits(smi->map, RTL8365MB_INTR_CTRL_REG,
+	return regmap_update_bits(priv->map, RTL8365MB_INTR_CTRL_REG,
  				  RTL8365MB_INTR_LINK_CHANGE_MASK,
  				  FIELD_PREP(RTL8365MB_INTR_LINK_CHANGE_MASK,
  					     enable ? 1 : 0));
  }
  
-static int rtl8365mb_irq_enable(struct realtek_smi *smi)
+static int rtl8365mb_irq_enable(struct realtek_priv *priv)
  {
-	return rtl8365mb_set_irq_enable(smi, true);
+	return rtl8365mb_set_irq_enable(priv, true);
  }
  
-static int rtl8365mb_irq_disable(struct realtek_smi *smi)
+static int rtl8365mb_irq_disable(struct realtek_priv *priv)
  {
-	return rtl8365mb_set_irq_enable(smi, false);
+	return rtl8365mb_set_irq_enable(priv, false);
  }
  
-static int rtl8365mb_irq_setup(struct realtek_smi *smi)
+static int rtl8365mb_irq_setup(struct realtek_priv *priv)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	struct device_node *intc;
  	u32 irq_trig;
  	int virq;

@@ -1577,9 +1577,9 @@ static int rtl8365mb_irq_setup(struct realtek_smi *smi)
  	int ret;
  	int i;
  
-	intc = of_get_child_by_name(smi->dev->of_node, "interrupt-controller");
+	intc = of_get_child_by_name(priv->dev->of_node, "interrupt-controller");
  	if (!intc) {
-		dev_err(smi->dev, "missing child interrupt-controller node\n");
+		dev_err(priv->dev, "missing child interrupt-controller node\n");
  		return -EINVAL;
  	}
  

@@ -1587,24 +1587,24 @@ static int rtl8365mb_irq_setup(struct realtek_smi *smi)
  	irq = of_irq_get(intc, 0);
  	if (irq <= 0) {
  		if (irq != -EPROBE_DEFER)
-			dev_err(smi->dev, "failed to get parent irq: %d\n",
+			dev_err(priv->dev, "failed to get parent irq: %d\n",
  				irq);
  		ret = irq ? irq : -EINVAL;
  		goto out_put_node;
  	}
  
-	smi->irqdomain = irq_domain_add_linear(intc, smi->num_ports,
-					       &rtl8365mb_irqdomain_ops, smi);
-	if (!smi->irqdomain) {
-		dev_err(smi->dev, "failed to add irq domain\n");
+	priv->irqdomain = irq_domain_add_linear(intc, priv->num_ports,
+					       &rtl8365mb_irqdomain_ops, priv);
+	if (!priv->irqdomain) {
+		dev_err(priv->dev, "failed to add irq domain\n");
  		ret = -ENOMEM;
  		goto out_put_node;
  	}
  
-	for (i = 0; i < smi->num_ports; i++) {
-		virq = irq_create_mapping(smi->irqdomain, i);
+	for (i = 0; i < priv->num_ports; i++) {
+		virq = irq_create_mapping(priv->irqdomain, i);
  		if (!virq) {
-			dev_err(smi->dev,
+			dev_err(priv->dev,
  				"failed to create irq domain mapping\n");
  			ret = -EINVAL;
  			goto out_remove_irqdomain;

@@ -1625,40 +1625,40 @@ static int rtl8365mb_irq_setup(struct realtek_smi *smi)
  		val = RTL8365MB_INTR_POLARITY_LOW;
  		break;
  	default:
-		dev_err(smi->dev, "unsupported irq trigger type %u\n",
+		dev_err(priv->dev, "unsupported irq trigger type %u\n",
  			irq_trig);
  		ret = -EINVAL;
  		goto out_remove_irqdomain;
  	}
  
-	ret = regmap_update_bits(smi->map, RTL8365MB_INTR_POLARITY_REG,
+	ret = regmap_update_bits(priv->map, RTL8365MB_INTR_POLARITY_REG,
  				 RTL8365MB_INTR_POLARITY_MASK,
  				 FIELD_PREP(RTL8365MB_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(smi);
+	ret = rtl8365mb_irq_disable(priv);
  	if (ret)
  		goto out_remove_irqdomain;
  
  	/* Clear the interrupt status register */
-	ret = regmap_write(smi->map, RTL8365MB_INTR_STATUS_REG,
+	ret = regmap_write(priv->map, RTL8365MB_INTR_STATUS_REG,
  			   RTL8365MB_INTR_ALL_MASK);
  	if (ret)
  		goto out_remove_irqdomain;
  
  	ret = request_threaded_irq(irq, NULL, rtl8365mb_irq, IRQF_ONESHOT,
-				   "rtl8365mb", smi);
+				   "rtl8365mb", priv);
  	if (ret) {
-		dev_err(smi->dev, "failed to request irq: %d\n", ret);
+		dev_err(priv->dev, "failed to request irq: %d\n", ret);
  		goto out_remove_irqdomain;
  	}
  
  	/* Store the irq so that we know to free it during teardown */
  	mb->irq = irq;
  
-	ret = rtl8365mb_irq_enable(smi);
+	ret = rtl8365mb_irq_enable(priv);
  	if (ret)
  		goto out_free_irq;
  

@@ -1667,17 +1667,17 @@ static int rtl8365mb_irq_setup(struct realtek_smi *smi)
  	return 0;
  
  out_free_irq:
-	free_irq(mb->irq, smi);
+	free_irq(mb->irq, priv);
  	mb->irq = 0;
  
  out_remove_irqdomain:
-	for (i = 0; i < smi->num_ports; i++) {
-		virq = irq_find_mapping(smi->irqdomain, i);
+	for (i = 0; i < priv->num_ports; i++) {
+		virq = irq_find_mapping(priv->irqdomain, i);
  		irq_dispose_mapping(virq);
  	}
  
-	irq_domain_remove(smi->irqdomain);
-	smi->irqdomain = NULL;
+	irq_domain_remove(priv->irqdomain);
+	priv->irqdomain = NULL;
  
  out_put_node:
  	of_node_put(intc);

@@ -1685,36 +1685,36 @@ static int rtl8365mb_irq_setup(struct realtek_smi *smi)
  	return ret;
  }
  
-static void rtl8365mb_irq_teardown(struct realtek_smi *smi)
+static void rtl8365mb_irq_teardown(struct realtek_priv *priv)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	int virq;
  	int i;
  
  	if (mb->irq) {
-		free_irq(mb->irq, smi);
+		free_irq(mb->irq, priv);
  		mb->irq = 0;
  	}
  
-	if (smi->irqdomain) {
-		for (i = 0; i < smi->num_ports; i++) {
-			virq = irq_find_mapping(smi->irqdomain, i);
+	if (priv->irqdomain) {
+		for (i = 0; i < priv->num_ports; i++) {
+			virq = irq_find_mapping(priv->irqdomain, i);
  			irq_dispose_mapping(virq);
  		}
  
-		irq_domain_remove(smi->irqdomain);
-		smi->irqdomain = NULL;
+		irq_domain_remove(priv->irqdomain);
+		priv->irqdomain = NULL;
  	}
  }
  
-static int rtl8365mb_cpu_config(struct realtek_smi *smi)
+static int rtl8365mb_cpu_config(struct realtek_priv *priv)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	struct rtl8365mb_cpu *cpu = &mb->cpu;
  	u32 val;
  	int ret;
  
-	ret = regmap_update_bits(smi->map, RTL8365MB_CPU_PORT_MASK_REG,
+	ret = regmap_update_bits(priv->map, RTL8365MB_CPU_PORT_MASK_REG,
  				 RTL8365MB_CPU_PORT_MASK_MASK,
  				 FIELD_PREP(RTL8365MB_CPU_PORT_MASK_MASK,
  					    cpu->mask));

@@ -1729,23 +1729,23 @@ static int rtl8365mb_cpu_config(struct realtek_smi *smi)
  	      FIELD_PREP(RTL8365MB_CPU_CTRL_TRAP_PORT_MASK, cpu->trap_port) |
  	      FIELD_PREP(RTL8365MB_CPU_CTRL_TRAP_PORT_EXT_MASK,
  			 cpu->trap_port >> 3);
-	ret = regmap_write(smi->map, RTL8365MB_CPU_CTRL_REG, val);
+	ret = regmap_write(priv->map, RTL8365MB_CPU_CTRL_REG, val);
  	if (ret)
  		return ret;
  
  	return 0;
  }
  
-static int rtl8365mb_switch_init(struct realtek_smi *smi)
+static int rtl8365mb_switch_init(struct realtek_priv *priv)
  {
-	struct rtl8365mb *mb = smi->chip_data;
+	struct rtl8365mb *mb = priv->chip_data;
  	int ret;
  	int i;
  
  	/* Do any chip-specific init jam before getting to the common stuff */
  	if (mb->jam_table) {
  		for (i = 0; i < mb->jam_size; i++) {
-			ret = regmap_write(smi->map, mb->jam_table[i].reg,
+			ret = regmap_write(priv->map, mb->jam_table[i].reg,
  					   mb->jam_table[i].val);
  			if (ret)
  				return ret;

@@ -1754,7 +1754,7 @@ static int rtl8365mb_switch_init(struct realtek_smi *smi)
  
  	/* Common init jam */
  	for (i = 0; i < ARRAY_SIZE(rtl8365mb_init_jam_common); i++) {
-		ret = regmap_write(smi->map, rtl8365mb_init_jam_common[i].reg,
+		ret = regmap_write(priv->map, rtl8365mb_init_jam_common[i].reg,
  				   rtl8365mb_init_jam_common[i].val);
  		if (ret)
  			return ret;

@@ -1763,11 +1763,11 @@ static int rtl8365mb_switch_init(struct realtek_smi *smi)
  	return 0;
  }
  
-static int rtl8365mb_reset_chip(struct realtek_smi *smi)
+static int rtl8365mb_reset_chip(struct realtek_priv *priv)
  {
  	u32 val;
  
-	realtek_smi_write_reg_noack(smi, RTL8365MB_CHIP_RESET_REG,
+	priv->write_reg_noack(priv, RTL8365MB_CHIP_RESET_REG,
  				    FIELD_PREP(RTL8365MB_CHIP_RESET_HW_MASK,
  					       1));