[linux-2.6-block.git] / drivers / net / dsa / rtl8366.c

// SPDX-License-Identifier: GPL-2.0
/* Realtek SMI library helpers for the RTL8366x variants
 * RTL8366RB and RTL8366S
 *
 * Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
 * Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org>
 * Copyright (C) 2010 Antti Seppälä <a.seppala@gmail.com>
 * Copyright (C) 2010 Roman Yeryomin <roman@advem.lv>
 * Copyright (C) 2011 Colin Leitner <colin.leitner@googlemail.com>
 */
#include <linux/if_bridge.h>
#include <net/dsa.h>

#include "realtek-smi-core.h"

int rtl8366_mc_is_used(struct realtek_smi *smi, int mc_index, int *used)
{
	int ret;
	int i;

	*used = 0;
	for (i = 0; i < smi->num_ports; i++) {
		int index = 0;

		ret = smi->ops->get_mc_index(smi, i, &index);
		if (ret)
			return ret;

		if (mc_index == index) {
			*used = 1;
			break;
		}
	}

	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_mc_is_used);

/**
 * rtl8366_obtain_mc() - retrieve or allocate a VLAN member configuration
 * @smi: the Realtek SMI device instance
 * @vid: the VLAN ID to look up or allocate
 * @vlanmc: the pointer will be assigned to a pointer to a valid member config
 * if successful
 * @return: index of a new member config or negative error number
 */
static int rtl8366_obtain_mc(struct realtek_smi *smi, int vid,
			     struct rtl8366_vlan_mc *vlanmc)
{
	struct rtl8366_vlan_4k vlan4k;
	int ret;
	int i;

	/* Try to find an existing member config entry for this VID */
	for (i = 0; i < smi->num_vlan_mc; i++) {
		ret = smi->ops->get_vlan_mc(smi, i, vlanmc);
		if (ret) {
			dev_err(smi->dev, "error searching for VLAN MC %d for VID %d\n",
				i, vid);
			return ret;
		}

		if (vid == vlanmc->vid)
			return i;
	}

	/* We have no MC entry for this VID, try to find an empty one */
	for (i = 0; i < smi->num_vlan_mc; i++) {
		ret = smi->ops->get_vlan_mc(smi, i, vlanmc);
		if (ret) {
			dev_err(smi->dev, "error searching for VLAN MC %d for VID %d\n",
				i, vid);
			return ret;
		}

		if (vlanmc->vid == 0 && vlanmc->member == 0) {
			/* Update the entry from the 4K table */
			ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
			if (ret) {
				dev_err(smi->dev, "error looking for 4K VLAN MC %d for VID %d\n",
					i, vid);
				return ret;
			}

			vlanmc->vid = vid;
			vlanmc->member = vlan4k.member;
			vlanmc->untag = vlan4k.untag;
			vlanmc->fid = vlan4k.fid;
			ret = smi->ops->set_vlan_mc(smi, i, vlanmc);
			if (ret) {
				dev_err(smi->dev, "unable to set/update VLAN MC %d for VID %d\n",
					i, vid);
				return ret;
			}

			dev_dbg(smi->dev, "created new MC at index %d for VID %d\n",
				i, vid);
			return i;
		}
	}

	/* MC table is full, try to find an unused entry and replace it */
	for (i = 0; i < smi->num_vlan_mc; i++) {
		int used;

		ret = rtl8366_mc_is_used(smi, i, &used);
		if (ret)
			return ret;

		if (!used) {
			/* Update the entry from the 4K table */
			ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
			if (ret)
				return ret;

			vlanmc->vid = vid;
			vlanmc->member = vlan4k.member;
			vlanmc->untag = vlan4k.untag;
			vlanmc->fid = vlan4k.fid;
			ret = smi->ops->set_vlan_mc(smi, i, vlanmc);
			if (ret) {
				dev_err(smi->dev, "unable to set/update VLAN MC %d for VID %d\n",
					i, vid);
				return ret;
			}
			dev_dbg(smi->dev, "recycled MC at index %i for VID %d\n",
				i, vid);
			return i;
		}
	}

	dev_err(smi->dev, "all VLAN member configurations are in use\n");
	return -ENOSPC;
}

int rtl8366_set_vlan(struct realtek_smi *smi, int vid, u32 member,
		     u32 untag, u32 fid)
{
	struct rtl8366_vlan_mc vlanmc;
	struct rtl8366_vlan_4k vlan4k;
	int mc;
	int ret;

	if (!smi->ops->is_vlan_valid(smi, vid))
		return -EINVAL;

	dev_dbg(smi->dev,
		"setting VLAN%d 4k members: 0x%02x, untagged: 0x%02x\n",
		vid, member, untag);

	/* Update the 4K table */
	ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
	if (ret)
		return ret;

	vlan4k.member |= member;
	vlan4k.untag |= untag;
	vlan4k.fid = fid;
	ret = smi->ops->set_vlan_4k(smi, &vlan4k);
	if (ret)
		return ret;

	dev_dbg(smi->dev,
		"resulting VLAN%d 4k members: 0x%02x, untagged: 0x%02x\n",
		vid, vlan4k.member, vlan4k.untag);

	/* Find or allocate a member config for this VID */
	ret = rtl8366_obtain_mc(smi, vid, &vlanmc);
	if (ret < 0)
		return ret;
	mc = ret;

	/* Update the MC entry */
	vlanmc.member |= member;
	vlanmc.untag |= untag;
	vlanmc.fid = fid;

	/* Commit updates to the MC entry */
	ret = smi->ops->set_vlan_mc(smi, mc, &vlanmc);
	if (ret)
		dev_err(smi->dev, "failed to commit changes to VLAN MC index %d for VID %d\n",
			mc, vid);
	else
		dev_dbg(smi->dev,
			"resulting VLAN%d MC members: 0x%02x, untagged: 0x%02x\n",
			vid, vlanmc.member, vlanmc.untag);

	return ret;
}
EXPORT_SYMBOL_GPL(rtl8366_set_vlan);

int rtl8366_set_pvid(struct realtek_smi *smi, unsigned int port,
		     unsigned int vid)
{
	struct rtl8366_vlan_mc vlanmc;
	int mc;
	int ret;

	if (!smi->ops->is_vlan_valid(smi, vid))
		return -EINVAL;

	/* Find or allocate a member config for this VID */
	ret = rtl8366_obtain_mc(smi, vid, &vlanmc);
	if (ret < 0)
		return ret;
	mc = ret;

	ret = smi->ops->set_mc_index(smi, port, mc);
	if (ret) {
		dev_err(smi->dev, "set PVID: failed to set MC index %d for port %d\n",
			mc, port);
		return ret;
	}

	dev_dbg(smi->dev, "set PVID: the PVID for port %d set to %d using existing MC index %d\n",
		port, vid, mc);

	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_set_pvid);

int rtl8366_enable_vlan4k(struct realtek_smi *smi, bool enable)
{
	int ret;

	/* To enable 4k VLAN, ordinary VLAN must be enabled first,
	 * but if we disable 4k VLAN it is fine to leave ordinary
	 * VLAN enabled.
	 */
	if (enable) {
		/* Make sure VLAN is ON */
		ret = smi->ops->enable_vlan(smi, true);
		if (ret)
			return ret;

		smi->vlan_enabled = true;
	}

	ret = smi->ops->enable_vlan4k(smi, enable);
	if (ret)
		return ret;

	smi->vlan4k_enabled = enable;
	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_enable_vlan4k);

int rtl8366_enable_vlan(struct realtek_smi *smi, bool enable)
{
	int ret;

	ret = smi->ops->enable_vlan(smi, enable);
	if (ret)
		return ret;

	smi->vlan_enabled = enable;

	/* If we turn VLAN off, make sure that we turn off
	 * 4k VLAN as well, if that happened to be on.
	 */
	if (!enable) {
		smi->vlan4k_enabled = false;
		ret = smi->ops->enable_vlan4k(smi, false);
	}

	return ret;
}
EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);

int rtl8366_reset_vlan(struct realtek_smi *smi)
{
	struct rtl8366_vlan_mc vlanmc;
	int ret;
	int i;

	rtl8366_enable_vlan(smi, false);
	rtl8366_enable_vlan4k(smi, false);

	/* Clear the 16 VLAN member configurations */
	vlanmc.vid = 0;
	vlanmc.priority = 0;
	vlanmc.member = 0;
	vlanmc.untag = 0;
	vlanmc.fid = 0;
	for (i = 0; i < smi->num_vlan_mc; i++) {
		ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
		if (ret)
			return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);

int rtl8366_init_vlan(struct realtek_smi *smi)
{
	int port;
	int ret;

	ret = rtl8366_reset_vlan(smi);
	if (ret)
		return ret;

	/* Loop over the available ports, for each port, associate
	 * it with the VLAN (port+1)
	 */
	for (port = 0; port < smi->num_ports; port++) {
		u32 mask;

		if (port == smi->cpu_port)
			/* For the CPU port, make all ports members of this
			 * VLAN.
			 */
			mask = GENMASK((int)smi->num_ports - 1, 0);
		else
			/* For all other ports, enable itself plus the
			 * CPU port.
			 */
			mask = BIT(port) | BIT(smi->cpu_port);

		/* For each port, set the port as member of VLAN (port+1)
		 * and untagged, except for the CPU port: the CPU port (5) is
		 * member of VLAN 6 and so are ALL the other ports as well.
		 * Use filter 0 (no filter).
		 */
		dev_info(smi->dev, "VLAN%d port mask for port %d, %08x\n",
			 (port + 1), port, mask);
		ret = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
		if (ret)
			return ret;

		dev_info(smi->dev, "VLAN%d port %d, PVID set to %d\n",
			 (port + 1), port, (port + 1));
		ret = rtl8366_set_pvid(smi, port, (port + 1));
		if (ret)
			return ret;
	}

	return rtl8366_enable_vlan(smi, true);
}
EXPORT_SYMBOL_GPL(rtl8366_init_vlan);

int rtl8366_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
			   struct netlink_ext_ack *extack)
{
	struct realtek_smi *smi = ds->priv;
	struct rtl8366_vlan_4k vlan4k;
	int ret;

	/* Use VLAN nr port + 1 since VLAN0 is not valid */
	if (!smi->ops->is_vlan_valid(smi, port + 1))
		return -EINVAL;

	dev_info(smi->dev, "%s filtering on port %d\n",
		 vlan_filtering ? "enable" : "disable",
		 port);

	/* TODO:
	 * The hardware support filter ID (FID) 0..7, I have no clue how to
	 * support this in the driver when the callback only says on/off.
	 */
	ret = smi->ops->get_vlan_4k(smi, port + 1, &vlan4k);
	if (ret)
		return ret;

	/* Just set the filter to FID 1 for now then */
	ret = rtl8366_set_vlan(smi, port + 1,
			       vlan4k.member,
			       vlan4k.untag,
			       1);
	if (ret)
		return ret;

	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_vlan_filtering);

int rtl8366_vlan_add(struct dsa_switch *ds, int port,
		     const struct switchdev_obj_port_vlan *vlan,
		     struct netlink_ext_ack *extack)
{
	bool untagged = !!(vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED);
	bool pvid = !!(vlan->flags & BRIDGE_VLAN_INFO_PVID);
	struct realtek_smi *smi = ds->priv;
	u32 member = 0;
	u32 untag = 0;
	int ret;

	if (!smi->ops->is_vlan_valid(smi, vlan->vid)) {
		NL_SET_ERR_MSG_MOD(extack, "VLAN ID not valid");
		return -EINVAL;
	}

	/* Enable VLAN in the hardware
	 * FIXME: what's with this 4k business?
	 * Just rtl8366_enable_vlan() seems inconclusive.
	 */
	ret = rtl8366_enable_vlan4k(smi, true);
	if (ret) {
		NL_SET_ERR_MSG_MOD(extack, "Failed to enable VLAN 4K");
		return ret;
	}

	dev_info(smi->dev, "add VLAN %d on port %d, %s, %s\n",
		 vlan->vid, port, untagged ? "untagged" : "tagged",
		 pvid ? " PVID" : "no PVID");

	if (dsa_is_dsa_port(ds, port) || dsa_is_cpu_port(ds, port))
		dev_err(smi->dev, "port is DSA or CPU port\n");

	member |= BIT(port);

	if (untagged)
		untag |= BIT(port);

	ret = rtl8366_set_vlan(smi, vlan->vid, member, untag, 0);
	if (ret) {
		dev_err(smi->dev, "failed to set up VLAN %04x", vlan->vid);
		return ret;
	}

	if (!pvid)
		return 0;

	ret = rtl8366_set_pvid(smi, port, vlan->vid);
	if (ret) {
		dev_err(smi->dev, "failed to set PVID on port %d to VLAN %04x",
			port, vlan->vid);
		return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_vlan_add);

int rtl8366_vlan_del(struct dsa_switch *ds, int port,
		     const struct switchdev_obj_port_vlan *vlan)
{
	struct realtek_smi *smi = ds->priv;
	int ret, i;

	dev_info(smi->dev, "del VLAN %04x on port %d\n", vlan->vid, port);

	for (i = 0; i < smi->num_vlan_mc; i++) {
		struct rtl8366_vlan_mc vlanmc;

		ret = smi->ops->get_vlan_mc(smi, i, &vlanmc);
		if (ret)
			return ret;

		if (vlan->vid == vlanmc.vid) {
			/* Remove this port from the VLAN */
			vlanmc.member &= ~BIT(port);
			vlanmc.untag &= ~BIT(port);
			/*
			 * If no ports are members of this VLAN
			 * anymore then clear the whole member
			 * config so it can be reused.
			 */
			if (!vlanmc.member && vlanmc.untag) {
				vlanmc.vid = 0;
				vlanmc.priority = 0;
				vlanmc.fid = 0;
			}
			ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
			if (ret) {
				dev_err(smi->dev,
					"failed to remove VLAN %04x\n",
					vlan->vid);
				return ret;
			}
			break;
		}
	}

	return 0;
}
EXPORT_SYMBOL_GPL(rtl8366_vlan_del);

void rtl8366_get_strings(struct dsa_switch *ds, int port, u32 stringset,
			 uint8_t *data)
{
	struct realtek_smi *smi = ds->priv;
	struct rtl8366_mib_counter *mib;
	int i;

	if (port >= smi->num_ports)
		return;

	for (i = 0; i < smi->num_mib_counters; i++) {
		mib = &smi->mib_counters[i];
		strncpy(data + i * ETH_GSTRING_LEN,
			mib->name, ETH_GSTRING_LEN);
	}
}
EXPORT_SYMBOL_GPL(rtl8366_get_strings);

int rtl8366_get_sset_count(struct dsa_switch *ds, int port, int sset)
{
	struct realtek_smi *smi = ds->priv;

	/* We only support SS_STATS */
	if (sset != ETH_SS_STATS)
		return 0;
	if (port >= smi->num_ports)
		return -EINVAL;

	return smi->num_mib_counters;
}
EXPORT_SYMBOL_GPL(rtl8366_get_sset_count);

void rtl8366_get_ethtool_stats(struct dsa_switch *ds, int port, uint64_t *data)
{
	struct realtek_smi *smi = ds->priv;
	int i;
	int ret;

	if (port >= smi->num_ports)
		return;

	for (i = 0; i < smi->num_mib_counters; i++) {
		struct rtl8366_mib_counter *mib;
		u64 mibvalue = 0;

		mib = &smi->mib_counters[i];
		ret = smi->ops->get_mib_counter(smi, port, mib, &mibvalue);
		if (ret) {
			dev_err(smi->dev, "error reading MIB counter %s\n",
				mib->name);
		}
		data[i] = mibvalue;
	}
}
EXPORT_SYMBOL_GPL(rtl8366_get_ethtool_stats);
Commit	Line	Data
d8652956 LW	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Realtek SMI library helpers for the RTL8366x variants
	3	* RTL8366RB and RTL8366S
	4	*
	5	* Copyright (C) 2017 Linus Walleij <linus.walleij@linaro.org>
	6	* Copyright (C) 2009-2010 Gabor Juhos <juhosg@openwrt.org>
	7	* Copyright (C) 2010 Antti Seppälä <a.seppala@gmail.com>
	8	* Copyright (C) 2010 Roman Yeryomin <roman@advem.lv>
	9	* Copyright (C) 2011 Colin Leitner <colin.leitner@googlemail.com>
	10	*/
	11	#include <linux/if_bridge.h>
	12	#include <net/dsa.h>
	13
f0c03ee0	14	#include "realtek-smi-core.h"
d8652956 LW	15
	16	int rtl8366_mc_is_used(struct realtek_smi smi, int mc_index, int used)
	17	{
	18	int ret;
	19	int i;
	20
	21	*used = 0;
	22	for (i = 0; i < smi->num_ports; i++) {
	23	int index = 0;
	24
	25	ret = smi->ops->get_mc_index(smi, i, &index);
	26	if (ret)
	27	return ret;
	28
	29	if (mc_index == index) {
	30	*used = 1;
	31	break;
	32	}
	33	}
	34
	35	return 0;
	36	}
	37	EXPORT_SYMBOL_GPL(rtl8366_mc_is_used);
	38
7e1301ed LW	39	/**
	40	* rtl8366_obtain_mc() - retrieve or allocate a VLAN member configuration
	41	* @smi: the Realtek SMI device instance
	42	* @vid: the VLAN ID to look up or allocate
	43	* @vlanmc: the pointer will be assigned to a pointer to a valid member config
	44	* if successful
	45	* @return: index of a new member config or negative error number
	46	*/
	47	static int rtl8366_obtain_mc(struct realtek_smi *smi, int vid,
	48	struct rtl8366_vlan_mc *vlanmc)
	49	{
	50	struct rtl8366_vlan_4k vlan4k;
	51	int ret;
	52	int i;
	53
	54	/* Try to find an existing member config entry for this VID */
	55	for (i = 0; i < smi->num_vlan_mc; i++) {
	56	ret = smi->ops->get_vlan_mc(smi, i, vlanmc);
	57	if (ret) {
	58	dev_err(smi->dev, "error searching for VLAN MC %d for VID %d\n",
	59	i, vid);
	60	return ret;
	61	}
	62
	63	if (vid == vlanmc->vid)
	64	return i;
	65	}
	66
	67	/* We have no MC entry for this VID, try to find an empty one */
	68	for (i = 0; i < smi->num_vlan_mc; i++) {
	69	ret = smi->ops->get_vlan_mc(smi, i, vlanmc);
	70	if (ret) {
	71	dev_err(smi->dev, "error searching for VLAN MC %d for VID %d\n",
	72	i, vid);
	73	return ret;
	74	}
	75
	76	if (vlanmc->vid == 0 && vlanmc->member == 0) {
	77	/* Update the entry from the 4K table */
	78	ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
	79	if (ret) {
	80	dev_err(smi->dev, "error looking for 4K VLAN MC %d for VID %d\n",
	81	i, vid);
	82	return ret;
	83	}
	84
	85	vlanmc->vid = vid;
	86	vlanmc->member = vlan4k.member;
	87	vlanmc->untag = vlan4k.untag;
	88	vlanmc->fid = vlan4k.fid;
	89	ret = smi->ops->set_vlan_mc(smi, i, vlanmc);
	90	if (ret) {
	91	dev_err(smi->dev, "unable to set/update VLAN MC %d for VID %d\n",
	92	i, vid);
	93	return ret;
	94	}
	95
	96	dev_dbg(smi->dev, "created new MC at index %d for VID %d\n",
	97	i, vid);
	98	return i;
	99	}
	100	}
	101
	102	/* MC table is full, try to find an unused entry and replace it */
103	for (i = 0; i < smi->num_vlan_mc; i++) {
104	int used;
105
106	ret = rtl8366_mc_is_used(smi, i, &used);
107	if (ret)
108	return ret;
109
110	if (!used) {
111	/* Update the entry from the 4K table */
112	ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
113	if (ret)
114	return ret;
115
116	vlanmc->vid = vid;
117	vlanmc->member = vlan4k.member;
118	vlanmc->untag = vlan4k.untag;
119	vlanmc->fid = vlan4k.fid;
120	ret = smi->ops->set_vlan_mc(smi, i, vlanmc);
121	if (ret) {
122	dev_err(smi->dev, "unable to set/update VLAN MC %d for VID %d\n",
123	i, vid);
124	return ret;
125	}
126	dev_dbg(smi->dev, "recycled MC at index %i for VID %d\n",
127	i, vid);
128	return i;
129	}
130	}
131
132	dev_err(smi->dev, "all VLAN member configurations are in use\n");
133	return -ENOSPC;
134	}
135
d8652956 LW	136	int rtl8366_set_vlan(struct realtek_smi *smi, int vid, u32 member,
	137	u32 untag, u32 fid)
	138	{
7e1301ed	139	struct rtl8366_vlan_mc vlanmc;
d8652956	140	struct rtl8366_vlan_4k vlan4k;
7e1301ed	141	int mc;
d8652956	142	int ret;
d8652956	143
6641a2c4 LW	144	if (!smi->ops->is_vlan_valid(smi, vid))
	145	return -EINVAL;
	146
15ab7906 LW	147	dev_dbg(smi->dev,
	148	"setting VLAN%d 4k members: 0x%02x, untagged: 0x%02x\n",
	149	vid, member, untag);
	150
d8652956 LW	151	/* Update the 4K table */
	152	ret = smi->ops->get_vlan_4k(smi, vid, &vlan4k);
	153	if (ret)
	154	return ret;
	155
15ab7906 LW	156	vlan4k.member \|= member;
15ab7906 LW	157	vlan4k.untag \|= untag;
d8652956 LW	158	vlan4k.fid = fid;
	159	ret = smi->ops->set_vlan_4k(smi, &vlan4k);
	160	if (ret)
	161	return ret;
	162
15ab7906 LW	163	dev_dbg(smi->dev,
	164	"resulting VLAN%d 4k members: 0x%02x, untagged: 0x%02x\n",
	165	vid, vlan4k.member, vlan4k.untag);
	166
7e1301ed LW	167	/* Find or allocate a member config for this VID */
	168	ret = rtl8366_obtain_mc(smi, vid, &vlanmc);
	169	if (ret < 0)
	170	return ret;
	171	mc = ret;
15ab7906	172
7e1301ed LW	173	/* Update the MC entry */
	174	vlanmc.member \|= member;
	175	vlanmc.untag \|= untag;
	176	vlanmc.fid = fid;
15ab7906	177
7e1301ed LW	178	/* Commit updates to the MC entry */
	179	ret = smi->ops->set_vlan_mc(smi, mc, &vlanmc);
	180	if (ret)
	181	dev_err(smi->dev, "failed to commit changes to VLAN MC index %d for VID %d\n",
	182	mc, vid);
	183	else
	184	dev_dbg(smi->dev,
	185	"resulting VLAN%d MC members: 0x%02x, untagged: 0x%02x\n",
	186	vid, vlanmc.member, vlanmc.untag);
d8652956 LW	187
	188	return ret;
	189	}
	190	EXPORT_SYMBOL_GPL(rtl8366_set_vlan);
	191
d8652956 LW	192	int rtl8366_set_pvid(struct realtek_smi *smi, unsigned int port,
	193	unsigned int vid)
	194	{
	195	struct rtl8366_vlan_mc vlanmc;
7e1301ed	196	int mc;
d8652956	197	int ret;
d8652956	198
6641a2c4 LW	199	if (!smi->ops->is_vlan_valid(smi, vid))
	200	return -EINVAL;
	201
7e1301ed LW	202	/* Find or allocate a member config for this VID */
	203	ret = rtl8366_obtain_mc(smi, vid, &vlanmc);
	204	if (ret < 0)
	205	return ret;
	206	mc = ret;
d8652956	207
7e1301ed LW	208	ret = smi->ops->set_mc_index(smi, port, mc);
	209	if (ret) {
	210	dev_err(smi->dev, "set PVID: failed to set MC index %d for port %d\n",
	211	mc, port);
	212	return ret;
d8652956 LW	213	}
d8652956 LW	214
7e1301ed LW	215	dev_dbg(smi->dev, "set PVID: the PVID for port %d set to %d using existing MC index %d\n",
7e1301ed LW	216	port, vid, mc);
d8652956	217
7e1301ed	218	return 0;
d8652956 LW	219	}
	220	EXPORT_SYMBOL_GPL(rtl8366_set_pvid);
	221
	222	int rtl8366_enable_vlan4k(struct realtek_smi *smi, bool enable)
	223	{
	224	int ret;
	225
	226	/* To enable 4k VLAN, ordinary VLAN must be enabled first,
	227	* but if we disable 4k VLAN it is fine to leave ordinary
	228	* VLAN enabled.
	229	*/
	230	if (enable) {
	231	/* Make sure VLAN is ON */
	232	ret = smi->ops->enable_vlan(smi, true);
	233	if (ret)
	234	return ret;
	235
	236	smi->vlan_enabled = true;
	237	}
	238
	239	ret = smi->ops->enable_vlan4k(smi, enable);
	240	if (ret)
	241	return ret;
	242
	243	smi->vlan4k_enabled = enable;
	244	return 0;
	245	}
	246	EXPORT_SYMBOL_GPL(rtl8366_enable_vlan4k);
	247
	248	int rtl8366_enable_vlan(struct realtek_smi *smi, bool enable)
	249	{
	250	int ret;
	251
	252	ret = smi->ops->enable_vlan(smi, enable);
	253	if (ret)
	254	return ret;
	255
	256	smi->vlan_enabled = enable;
	257
	258	/* If we turn VLAN off, make sure that we turn off
	259	* 4k VLAN as well, if that happened to be on.
	260	*/
	261	if (!enable) {
	262	smi->vlan4k_enabled = false;
	263	ret = smi->ops->enable_vlan4k(smi, false);
	264	}
	265
	266	return ret;
	267	}
	268	EXPORT_SYMBOL_GPL(rtl8366_enable_vlan);
	269
	270	int rtl8366_reset_vlan(struct realtek_smi *smi)
	271	{
	272	struct rtl8366_vlan_mc vlanmc;
d8652956 LW	273	int ret;
	274	int i;
	275
	276	rtl8366_enable_vlan(smi, false);
	277	rtl8366_enable_vlan4k(smi, false);
	278
	279	/* Clear the 16 VLAN member configurations */
	280	vlanmc.vid = 0;
	281	vlanmc.priority = 0;
	282	vlanmc.member = 0;
	283	vlanmc.untag = 0;
	284	vlanmc.fid = 0;
	285	for (i = 0; i < smi->num_vlan_mc; i++) {
	286	ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
	287	if (ret)
	288	return ret;
	289	}
	290
	291	return 0;
	292	}
	293	EXPORT_SYMBOL_GPL(rtl8366_reset_vlan);
	294
	295	int rtl8366_init_vlan(struct realtek_smi *smi)
	296	{
	297	int port;
	298	int ret;
	299
	300	ret = rtl8366_reset_vlan(smi);
	301	if (ret)
	302	return ret;
	303
	304	/* Loop over the available ports, for each port, associate
	305	* it with the VLAN (port+1)
	306	*/
	307	for (port = 0; port < smi->num_ports; port++) {
	308	u32 mask;
	309
	310	if (port == smi->cpu_port)
	311	/* For the CPU port, make all ports members of this
	312	* VLAN.
	313	*/
da31735c	314	mask = GENMASK((int)smi->num_ports - 1, 0);
d8652956 LW	315	else
	316	/* For all other ports, enable itself plus the
	317	* CPU port.
	318	*/
	319	mask = BIT(port) \| BIT(smi->cpu_port);
	320
	321	/* For each port, set the port as member of VLAN (port+1)
	322	* and untagged, except for the CPU port: the CPU port (5) is
	323	* member of VLAN 6 and so are ALL the other ports as well.
	324	* Use filter 0 (no filter).
	325	*/
	326	dev_info(smi->dev, "VLAN%d port mask for port %d, %08x\n",
	327	(port + 1), port, mask);
	328	ret = rtl8366_set_vlan(smi, (port + 1), mask, mask, 0);
	329	if (ret)
	330	return ret;
	331
	332	dev_info(smi->dev, "VLAN%d port %d, PVID set to %d\n",
	333	(port + 1), port, (port + 1));
	334	ret = rtl8366_set_pvid(smi, port, (port + 1));
	335	if (ret)
	336	return ret;
	337	}
	338
	339	return rtl8366_enable_vlan(smi, true);
	340	}
	341	EXPORT_SYMBOL_GPL(rtl8366_init_vlan);
	342
89153ed6 VO	343	int rtl8366_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
89153ed6 VO	344	struct netlink_ext_ack *extack)
d8652956 LW	345	{
	346	struct realtek_smi *smi = ds->priv;
	347	struct rtl8366_vlan_4k vlan4k;
	348	int ret;
	349
760c80b7	350	/* Use VLAN nr port + 1 since VLAN0 is not valid */
bae33f2b VO	351	if (!smi->ops->is_vlan_valid(smi, port + 1))
bae33f2b VO	352	return -EINVAL;
d8652956 LW	353
	354	dev_info(smi->dev, "%s filtering on port %d\n",
	355	vlan_filtering ? "enable" : "disable",
	356	port);
	357
	358	/* TODO:
	359	* The hardware support filter ID (FID) 0..7, I have no clue how to
	360	* support this in the driver when the callback only says on/off.
	361	*/
760c80b7	362	ret = smi->ops->get_vlan_4k(smi, port + 1, &vlan4k);
d8652956 LW	363	if (ret)
	364	return ret;
	365
	366	/* Just set the filter to FID 1 for now then */
760c80b7	367	ret = rtl8366_set_vlan(smi, port + 1,
d8652956 LW	368	vlan4k.member,
	369	vlan4k.untag,
	370	1);
	371	if (ret)
	372	return ret;
	373
	374	return 0;
	375	}
	376	EXPORT_SYMBOL_GPL(rtl8366_vlan_filtering);
	377
1958d581	378	int rtl8366_vlan_add(struct dsa_switch *ds, int port,
31046a5f VO	379	const struct switchdev_obj_port_vlan *vlan,
31046a5f VO	380	struct netlink_ext_ack *extack)
d8652956	381	{
1958d581 VO	382	bool untagged = !!(vlan->flags & BRIDGE_VLAN_INFO_UNTAGGED);
1958d581 VO	383	bool pvid = !!(vlan->flags & BRIDGE_VLAN_INFO_PVID);
d8652956	384	struct realtek_smi *smi = ds->priv;
1958d581 VO	385	u32 member = 0;
	386	u32 untag = 0;
	387	int ret;
d8652956	388
31046a5f VO	389	if (!smi->ops->is_vlan_valid(smi, vlan->vid)) {
31046a5f VO	390	NL_SET_ERR_MSG_MOD(extack, "VLAN ID not valid");
b7a9e0da	391	return -EINVAL;
31046a5f	392	}
d8652956	393
d8652956 LW	394	/* Enable VLAN in the hardware
	395	* FIXME: what's with this 4k business?
	396	* Just rtl8366_enable_vlan() seems inconclusive.
	397	*/
1958d581	398	ret = rtl8366_enable_vlan4k(smi, true);
31046a5f VO	399	if (ret) {
31046a5f VO	400	NL_SET_ERR_MSG_MOD(extack, "Failed to enable VLAN 4K");
1958d581	401	return ret;
31046a5f	402	}
d8652956	403
7e1301ed	404	dev_info(smi->dev, "add VLAN %d on port %d, %s, %s\n",
b7a9e0da	405	vlan->vid, port, untagged ? "untagged" : "tagged",
d8652956 LW	406	pvid ? " PVID" : "no PVID");
	407
	408	if (dsa_is_dsa_port(ds, port) \|\| dsa_is_cpu_port(ds, port))
	409	dev_err(smi->dev, "port is DSA or CPU port\n");
	410
b7a9e0da	411	member \|= BIT(port);
d8652956	412
b7a9e0da VO	413	if (untagged)
b7a9e0da VO	414	untag \|= BIT(port);
d8652956	415
b7a9e0da	416	ret = rtl8366_set_vlan(smi, vlan->vid, member, untag, 0);
1958d581	417	if (ret) {
b7a9e0da	418	dev_err(smi->dev, "failed to set up VLAN %04x", vlan->vid);
1958d581 VO	419	return ret;
1958d581 VO	420	}
7e1301ed	421
b7a9e0da	422	if (!pvid)
1958d581	423	return 0;
3dfe8dde	424
b7a9e0da	425	ret = rtl8366_set_pvid(smi, port, vlan->vid);
1958d581	426	if (ret) {
b7a9e0da VO	427	dev_err(smi->dev, "failed to set PVID on port %d to VLAN %04x",
b7a9e0da VO	428	port, vlan->vid);
1958d581 VO	429	return ret;
1958d581 VO	430	}
7e1301ed	431
1958d581	432	return 0;
d8652956 LW	433	}
	434	EXPORT_SYMBOL_GPL(rtl8366_vlan_add);
	435
	436	int rtl8366_vlan_del(struct dsa_switch *ds, int port,
	437	const struct switchdev_obj_port_vlan *vlan)
	438	{
	439	struct realtek_smi *smi = ds->priv;
b7a9e0da	440	int ret, i;
d8652956	441
b7a9e0da	442	dev_info(smi->dev, "del VLAN %04x on port %d\n", vlan->vid, port);
d8652956	443
b7a9e0da VO	444	for (i = 0; i < smi->num_vlan_mc; i++) {
b7a9e0da VO	445	struct rtl8366_vlan_mc vlanmc;
d8652956	446
b7a9e0da VO	447	ret = smi->ops->get_vlan_mc(smi, i, &vlanmc);
	448	if (ret)
	449	return ret;
d8652956	450
b7a9e0da VO	451	if (vlan->vid == vlanmc.vid) {
	452	/* Remove this port from the VLAN */
	453	vlanmc.member &= ~BIT(port);
	454	vlanmc.untag &= ~BIT(port);
	455	/*
	456	* If no ports are members of this VLAN
	457	* anymore then clear the whole member
	458	* config so it can be reused.
	459	*/
	460	if (!vlanmc.member && vlanmc.untag) {
	461	vlanmc.vid = 0;
	462	vlanmc.priority = 0;
	463	vlanmc.fid = 0;
	464	}
	465	ret = smi->ops->set_vlan_mc(smi, i, &vlanmc);
	466	if (ret) {
	467	dev_err(smi->dev,
	468	"failed to remove VLAN %04x\n",
	469	vlan->vid);
d8652956	470	return ret;
d8652956	471	}
b7a9e0da	472	break;
d8652956 LW	473	}
	474	}
	475
	476	return 0;
	477	}
	478	EXPORT_SYMBOL_GPL(rtl8366_vlan_del);
	479
	480	void rtl8366_get_strings(struct dsa_switch *ds, int port, u32 stringset,
	481	uint8_t *data)
	482	{
	483	struct realtek_smi *smi = ds->priv;
	484	struct rtl8366_mib_counter *mib;
	485	int i;
	486
	487	if (port >= smi->num_ports)
	488	return;
	489
	490	for (i = 0; i < smi->num_mib_counters; i++) {
	491	mib = &smi->mib_counters[i];
	492	strncpy(data + i * ETH_GSTRING_LEN,
	493	mib->name, ETH_GSTRING_LEN);
	494	}
	495	}
	496	EXPORT_SYMBOL_GPL(rtl8366_get_strings);
	497
	498	int rtl8366_get_sset_count(struct dsa_switch *ds, int port, int sset)
	499	{
	500	struct realtek_smi *smi = ds->priv;
	501
	502	/* We only support SS_STATS */
	503	if (sset != ETH_SS_STATS)
	504	return 0;
	505	if (port >= smi->num_ports)
	506	return -EINVAL;
	507
	508	return smi->num_mib_counters;
	509	}
	510	EXPORT_SYMBOL_GPL(rtl8366_get_sset_count);
	511
	512	void rtl8366_get_ethtool_stats(struct dsa_switch ds, int port, uint64_t data)
	513	{
	514	struct realtek_smi *smi = ds->priv;
	515	int i;
	516	int ret;
	517
	518	if (port >= smi->num_ports)
	519	return;
	520
	521	for (i = 0; i < smi->num_mib_counters; i++) {
	522	struct rtl8366_mib_counter *mib;
	523	u64 mibvalue = 0;
	524
	525	mib = &smi->mib_counters[i];
	526	ret = smi->ops->get_mib_counter(smi, port, mib, &mibvalue);
	527	if (ret) {
	528	dev_err(smi->dev, "error reading MIB counter %s\n",
	529	mib->name);
	530	}
	531	data[i] = mibvalue;
	532	}
	533	}
	534	EXPORT_SYMBOL_GPL(rtl8366_get_ethtool_stats);