Commit adb3dccf authored by Vladimir Oltean's avatar Vladimir Oltean Committed by Jakub Kicinski
Browse files

net: dsa: felix: convert to the new .change_tag_protocol DSA API 



In expectation of the new tag_ocelot_8021q tagger implementation, we
need to be able to do runtime switchover between one tagger and another.
So we must structure the existing code for the current NPI-based tagger
in a certain way.

We move the felix_npi_port_init function in expectation of the future
driver configuration necessary for tag_ocelot_8021q: we would like to
not have the NPI-related bits interspersed with the tag_8021q bits.

The conversion from this:

	ocelot_write_rix(ocelot,
			 ANA_PGID_PGID_PGID(GENMASK(ocelot->num_phys_ports, 0)),
			 ANA_PGID_PGID, PGID_UC);

to this:

	cpu_flood = ANA_PGID_PGID_PGID(BIT(ocelot->num_phys_ports));
	ocelot_rmw_rix(ocelot, cpu_flood, cpu_flood, ANA_PGID_PGID, PGID_UC);

is perhaps non-trivial, but is nonetheless non-functional. The PGID_UC
(replicator for unknown unicast) is already configured out of hardware
reset to flood to all ports except ocelot->num_phys_ports (the CPU port
module). All we change is that we use a read-modify-write to only add
the CPU port module to the unknown unicast replicator, as opposed to
doing a full write to the register.

Signed-off-by: default avatarVladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parent 53da0eba

drivers/net/dsa/ocelot/felix.c

+151 −35
Original line number Original line Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

// SPDX-License-Identifier: GPL-2.0

/* Copyright 2019 NXP Semiconductors

/* Copyright 2019-2021 NXP Semiconductors

 *

 *

 * This is an umbrella module for all network switches that are

 * This is an umbrella module for all network switches that are

 * register-compatible with Ocelot and that perform I/O to their host CPU

 * register-compatible with Ocelot and that perform I/O to their host CPU
@@ -24,11 +24,140 @@ 
#include <net/dsa.h>

#include <net/dsa.h>

#include "felix.h"

#include "felix.h"





/* The CPU port module is connected to the Node Processor Interface (NPI). This

 * is the mode through which frames can be injected from and extracted to an

 * external CPU, over Ethernet. In NXP SoCs, the "external CPU" is the ARM CPU

 * running Linux, and this forms a DSA setup together with the enetc or fman

 * DSA master.

 */

static void felix_npi_port_init(struct ocelot *ocelot, int port)

{

	ocelot->npi = port;



	ocelot_write(ocelot, QSYS_EXT_CPU_CFG_EXT_CPUQ_MSK_M |

		     QSYS_EXT_CPU_CFG_EXT_CPU_PORT(port),

		     QSYS_EXT_CPU_CFG);



	/* NPI port Injection/Extraction configuration */

	ocelot_fields_write(ocelot, port, SYS_PORT_MODE_INCL_XTR_HDR,

			    ocelot->npi_xtr_prefix);

	ocelot_fields_write(ocelot, port, SYS_PORT_MODE_INCL_INJ_HDR,

			    ocelot->npi_inj_prefix);



	/* Disable transmission of pause frames */

	ocelot_fields_write(ocelot, port, SYS_PAUSE_CFG_PAUSE_ENA, 0);

}



static void felix_npi_port_deinit(struct ocelot *ocelot, int port)

{

	/* Restore hardware defaults */

	int unused_port = ocelot->num_phys_ports + 2;



	ocelot->npi = -1;



	ocelot_write(ocelot, QSYS_EXT_CPU_CFG_EXT_CPU_PORT(unused_port),

		     QSYS_EXT_CPU_CFG);



	ocelot_fields_write(ocelot, port, SYS_PORT_MODE_INCL_XTR_HDR,

			    OCELOT_TAG_PREFIX_DISABLED);

	ocelot_fields_write(ocelot, port, SYS_PORT_MODE_INCL_INJ_HDR,

			    OCELOT_TAG_PREFIX_DISABLED);



	/* Enable transmission of pause frames */

	ocelot_fields_write(ocelot, port, SYS_PAUSE_CFG_PAUSE_ENA, 1);

}



static int felix_setup_tag_npi(struct dsa_switch *ds, int cpu)

{

	struct ocelot *ocelot = ds->priv;

	unsigned long cpu_flood;



	felix_npi_port_init(ocelot, cpu);



	/* Include the CPU port module (and indirectly, the NPI port)

	 * in the forwarding mask for unknown unicast - the hardware

	 * default value for ANA_FLOODING_FLD_UNICAST excludes

	 * BIT(ocelot->num_phys_ports), and so does ocelot_init,

	 * since Ocelot relies on whitelisting MAC addresses towards

	 * PGID_CPU.

	 * We do this because DSA does not yet perform RX filtering,

	 * and the NPI port does not perform source address learning,

	 * so traffic sent to Linux is effectively unknown from the

	 * switch's perspective.

	 */

	cpu_flood = ANA_PGID_PGID_PGID(BIT(ocelot->num_phys_ports));

	ocelot_rmw_rix(ocelot, cpu_flood, cpu_flood, ANA_PGID_PGID, PGID_UC);



	return 0;

}



static void felix_teardown_tag_npi(struct dsa_switch *ds, int cpu)

{

	struct ocelot *ocelot = ds->priv;



	felix_npi_port_deinit(ocelot, cpu);

}



static int felix_set_tag_protocol(struct dsa_switch *ds, int cpu,

				  enum dsa_tag_protocol proto)

{

	int err;



	switch (proto) {

	case DSA_TAG_PROTO_OCELOT:

		err = felix_setup_tag_npi(ds, cpu);

		break;

	default:

		err = -EPROTONOSUPPORT;

	}



	return err;

}



static void felix_del_tag_protocol(struct dsa_switch *ds, int cpu,

				   enum dsa_tag_protocol proto)

{

	switch (proto) {

	case DSA_TAG_PROTO_OCELOT:

		felix_teardown_tag_npi(ds, cpu);

		break;

	default:

		break;

	}

}



static int felix_change_tag_protocol(struct dsa_switch *ds, int cpu,

				     enum dsa_tag_protocol proto)

{

	struct ocelot *ocelot = ds->priv;

	struct felix *felix = ocelot_to_felix(ocelot);

	enum dsa_tag_protocol old_proto = felix->tag_proto;

	int err;



	if (proto != DSA_TAG_PROTO_OCELOT)

		return -EPROTONOSUPPORT;



	felix_del_tag_protocol(ds, cpu, old_proto);



	err = felix_set_tag_protocol(ds, cpu, proto);

	if (err) {

		felix_set_tag_protocol(ds, cpu, old_proto);

		return err;

	}



	felix->tag_proto = proto;



	return 0;

}



static enum dsa_tag_protocol felix_get_tag_protocol(struct dsa_switch *ds,

static enum dsa_tag_protocol felix_get_tag_protocol(struct dsa_switch *ds,

						    int port,

						    int port,

						    enum dsa_tag_protocol mp)

						    enum dsa_tag_protocol mp)

{

{

	return DSA_TAG_PROTO_OCELOT;

	struct ocelot *ocelot = ds->priv;

	struct felix *felix = ocelot_to_felix(ocelot);



	return felix->tag_proto;

}

}





static int felix_set_ageing_time(struct dsa_switch *ds,

static int felix_set_ageing_time(struct dsa_switch *ds,
@@ -527,28 +656,6 @@ static int felix_init_structs(struct felix *felix, int num_phys_ports) 
	return 0;

	return 0;

}

}





/* The CPU port module is connected to the Node Processor Interface (NPI). This

 * is the mode through which frames can be injected from and extracted to an

 * external CPU, over Ethernet.

 */

static void felix_npi_port_init(struct ocelot *ocelot, int port)

{

	ocelot->npi = port;



	ocelot_write(ocelot, QSYS_EXT_CPU_CFG_EXT_CPUQ_MSK_M |

		     QSYS_EXT_CPU_CFG_EXT_CPU_PORT(port),

		     QSYS_EXT_CPU_CFG);



	/* NPI port Injection/Extraction configuration */

	ocelot_fields_write(ocelot, port, SYS_PORT_MODE_INCL_XTR_HDR,

			    ocelot->npi_xtr_prefix);

	ocelot_fields_write(ocelot, port, SYS_PORT_MODE_INCL_INJ_HDR,

			    ocelot->npi_inj_prefix);



	/* Disable transmission of pause frames */

	ocelot_fields_write(ocelot, port, SYS_PAUSE_CFG_PAUSE_ENA, 0);

}



/* Hardware initialization done here so that we can allocate structures with

/* Hardware initialization done here so that we can allocate structures with

 * devm without fear of dsa_register_switch returning -EPROBE_DEFER and causing

 * devm without fear of dsa_register_switch returning -EPROBE_DEFER and causing

 * us to allocate structures twice (leak memory) and map PCI memory twice

 * us to allocate structures twice (leak memory) and map PCI memory twice
@@ -578,10 +685,10 @@ static int felix_setup(struct dsa_switch *ds) 
	}

	}





	for (port = 0; port < ds->num_ports; port++) {

	for (port = 0; port < ds->num_ports; port++) {

		ocelot_init_port(ocelot, port);

		if (dsa_is_unused_port(ds, port))

			continue;





		if (dsa_is_cpu_port(ds, port))

		ocelot_init_port(ocelot, port);

			felix_npi_port_init(ocelot, port);





		/* Set the default QoS Classification based on PCP and DEI

		/* Set the default QoS Classification based on PCP and DEI

		 * bits of vlan tag.

		 * bits of vlan tag.
@@ -593,14 +700,15 @@ static int felix_setup(struct dsa_switch *ds) 
	if (err)

	if (err)

		return err;

		return err;





	/* Include the CPU port module in the forwarding mask for unknown

	for (port = 0; port < ds->num_ports; port++) {

	 * unicast - the hardware default value for ANA_FLOODING_FLD_UNICAST

		if (!dsa_is_cpu_port(ds, port))

	 * excludes BIT(ocelot->num_phys_ports), and so does ocelot_init, since

			continue;

	 * Ocelot relies on whitelisting MAC addresses towards PGID_CPU.



		/* The initial tag protocol is NPI which always returns 0, so

		 * there's no real point in checking for errors.

		 */

		 */

	ocelot_write_rix(ocelot,

		felix_set_tag_protocol(ds, port, felix->tag_proto);

			 ANA_PGID_PGID_PGID(GENMASK(ocelot->num_phys_ports, 0)),

	}

			 ANA_PGID_PGID, PGID_UC);





	ds->mtu_enforcement_ingress = true;

	ds->mtu_enforcement_ingress = true;

	ds->assisted_learning_on_cpu_port = true;

	ds->assisted_learning_on_cpu_port = true;
@@ -614,6 +722,13 @@ static void felix_teardown(struct dsa_switch *ds) 
	struct felix *felix = ocelot_to_felix(ocelot);

	struct felix *felix = ocelot_to_felix(ocelot);

	int port;

	int port;





	for (port = 0; port < ds->num_ports; port++) {

		if (!dsa_is_cpu_port(ds, port))

			continue;



		felix_del_tag_protocol(ds, port, felix->tag_proto);

	}



	ocelot_devlink_sb_unregister(ocelot);

	ocelot_devlink_sb_unregister(ocelot);

	ocelot_deinit_timestamp(ocelot);

	ocelot_deinit_timestamp(ocelot);

	ocelot_deinit(ocelot);

	ocelot_deinit(ocelot);
@@ -860,6 +975,7 @@ static int felix_sb_occ_tc_port_bind_get(struct dsa_switch *ds, int port, 




const struct dsa_switch_ops felix_switch_ops = {

const struct dsa_switch_ops felix_switch_ops = {

	.get_tag_protocol		= felix_get_tag_protocol,

	.get_tag_protocol		= felix_get_tag_protocol,

	.change_tag_protocol		= felix_change_tag_protocol,

	.setup				= felix_setup,

	.setup				= felix_setup,

	.teardown			= felix_teardown,

	.teardown			= felix_teardown,

	.set_ageing_time		= felix_set_ageing_time,

	.set_ageing_time		= felix_set_ageing_time,

drivers/net/dsa/ocelot/felix.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -48,6 +48,7 @@ struct felix { 
	struct lynx_pcs			**pcs;

	struct lynx_pcs			**pcs;

	resource_size_t			switch_base;

	resource_size_t			switch_base;

	resource_size_t			imdio_base;

	resource_size_t			imdio_base;

	enum dsa_tag_protocol		tag_proto;

};

};





struct net_device *felix_port_to_netdev(struct ocelot *ocelot, int port);

struct net_device *felix_port_to_netdev(struct ocelot *ocelot, int port);

drivers/net/dsa/ocelot/felix_vsc9959.c

+1 −0
Original line number Original line Diff line number Diff line
@@ -1467,6 +1467,7 @@ static int felix_pci_probe(struct pci_dev *pdev, 
	ds->ops = &felix_switch_ops;

	ds->ops = &felix_switch_ops;

	ds->priv = ocelot;

	ds->priv = ocelot;

	felix->ds = ds;

	felix->ds = ds;

	felix->tag_proto = DSA_TAG_PROTO_OCELOT;





	err = dsa_register_switch(ds);

	err = dsa_register_switch(ds);

	if (err) {

	if (err) {

drivers/net/dsa/ocelot/seville_vsc9953.c

+1 −0
Original line number Original line Diff line number Diff line
@@ -1246,6 +1246,7 @@ static int seville_probe(struct platform_device *pdev) 
	ds->ops = &felix_switch_ops;

	ds->ops = &felix_switch_ops;

	ds->priv = ocelot;

	ds->priv = ocelot;

	felix->ds = ds;

	felix->ds = ds;

	felix->tag_proto = DSA_TAG_PROTO_OCELOT;





	err = dsa_register_switch(ds);

	err = dsa_register_switch(ds);

	if (err) {

	if (err) {