net: dsa: realtek: rename realtek_smi to realtek_priv (f5f11907) · Commits · EulixOS / Software / Kernel

drivers/net/dsa/realtek/realtek-smi-core.c

+158 −158

Original line number	Diff line number	Diff line
		@@ -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);
		}

drivers/net/dsa/realtek/realtek-smi-core.h→drivers/net/dsa/realtek/realtek.h

+34 −34

Original line number	Diff line number	Diff line
		@@ -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,7 @@ 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 vlan_enabled;
		int vlan4k_enabled;
		@@ -75,40 +75,40 @@ 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;
		@@ -116,19 +116,19 @@ struct realtek_smi_variant {
		};

		/* SMI core calls */
		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);
		int realtek_smi_setup_mdio(struct realtek_smi *smi);
		int realtek_smi_setup_mdio(struct realtek_priv *priv);

		/* 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 +139,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 */

drivers/net/dsa/realtek/rtl8365mb.c

+197 −197

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/dsa/realtek/rtl8366.c

+82 −82

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/dsa/realtek/rtl8366rb.c

+201 −201

File changed.

Preview size limit exceeded, changes collapsed.