leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'dsa-cleanups-before-multi-CPU-port'

Browse Source 
Florian Fainelli says:

====================
net: dsa: Cleanups before multi-CPU port

This patch series does a bunch of cleanups before we start adding support
for multiple CPU ports.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2017-06-04 20:05:15 -04:00
commit 2d9888c5b2
5 changed files with 66 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/net/dsa.h
View File

@ -254,7 +254,7 @@ struct dsa_switch {
static inline bool dsa_is_cpu_port(struct dsa_switch *ds, int p)
{
return ds->dst->cpu_dp == &ds->ports[p];
return !!(ds->cpu_port_mask & (1 << p));
}
static inline bool dsa_is_dsa_port(struct dsa_switch *ds, int p)

6
net/dsa/dsa.c
View File

@ -112,8 +112,9 @@ const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol)
return ops;
}
int dsa_cpu_port_ethtool_setup(struct dsa_switch *ds)
int dsa_cpu_port_ethtool_setup(struct dsa_port *cpu_dp)
{
struct dsa_switch *ds = cpu_dp->ds;
struct net_device *master;
struct ethtool_ops *cpu_ops;
@ -136,8 +137,9 @@ int dsa_cpu_port_ethtool_setup(struct dsa_switch *ds)
return 0;
}
void dsa_cpu_port_ethtool_restore(struct dsa_switch *ds)
void dsa_cpu_port_ethtool_restore(struct dsa_port *cpu_dp)
{
struct dsa_switch *ds = cpu_dp->ds;
struct net_device *master;
master = ds->dst->master_netdev;

125
net/dsa/dsa2.c
View File

@ -214,66 +214,59 @@ static int dsa_dst_complete(struct dsa_switch_tree *dst)
return 0;
}
static int dsa_dsa_port_apply(struct dsa_port *port, u32 index,
struct dsa_switch *ds)
static int dsa_dsa_port_apply(struct dsa_port *port)
{
struct dsa_switch *ds = port->ds;
int err;
err = dsa_cpu_dsa_setup(ds, ds->dev, port, index);
err = dsa_cpu_dsa_setup(ds, ds->dev, port, port->index);
if (err) {
dev_warn(ds->dev, "Failed to setup dsa port %d: %d\n",
index, err);
port->index, err);
return err;
}
memset(&ds->ports[index].devlink_port, 0,
sizeof(ds->ports[index].devlink_port));
memset(&port->devlink_port, 0, sizeof(port->devlink_port));
return devlink_port_register(ds->devlink,
&ds->ports[index].devlink_port,
index);
return devlink_port_register(ds->devlink, &port->devlink_port,
port->index);
}
static void dsa_dsa_port_unapply(struct dsa_port *port, u32 index,
struct dsa_switch *ds)
static void dsa_dsa_port_unapply(struct dsa_port *port)
{
devlink_port_unregister(&ds->ports[index].devlink_port);
devlink_port_unregister(&port->devlink_port);
dsa_cpu_dsa_destroy(port);
}
static int dsa_cpu_port_apply(struct dsa_port *port, u32 index,
struct dsa_switch *ds)
static int dsa_cpu_port_apply(struct dsa_port *port)
{
struct dsa_switch *ds = port->ds;
int err;
err = dsa_cpu_dsa_setup(ds, ds->dev, port, index);
err = dsa_cpu_dsa_setup(ds, ds->dev, port, port->index);
if (err) {
dev_warn(ds->dev, "Failed to setup cpu port %d: %d\n",
index, err);
port->index, err);
return err;
}
ds->cpu_port_mask |= BIT(index);
memset(&ds->ports[index].devlink_port, 0,
sizeof(ds->ports[index].devlink_port));
err = devlink_port_register(ds->devlink, &ds->ports[index].devlink_port,
index);
memset(&port->devlink_port, 0, sizeof(port->devlink_port));
err = devlink_port_register(ds->devlink, &port->devlink_port,
port->index);
return err;
}
static void dsa_cpu_port_unapply(struct dsa_port *port, u32 index,
struct dsa_switch *ds)
static void dsa_cpu_port_unapply(struct dsa_port *port)
{
devlink_port_unregister(&ds->ports[index].devlink_port);
devlink_port_unregister(&port->devlink_port);
dsa_cpu_dsa_destroy(port);
ds->cpu_port_mask &= ~BIT(index);
port->ds->cpu_port_mask &= ~BIT(port->index);
}
static int dsa_user_port_apply(struct dsa_port *port, u32 index,
struct dsa_switch *ds)
static int dsa_user_port_apply(struct dsa_port *port)
{
struct dsa_switch *ds = port->ds;
const char *name = port->name;
int err;
@ -282,35 +275,32 @@ static int dsa_user_port_apply(struct dsa_port *port, u32 index,
if (!name)
name = "eth%d";
err = dsa_slave_create(ds, ds->dev, index, name);
err = dsa_slave_create(ds, ds->dev, port->index, name);
if (err) {
dev_warn(ds->dev, "Failed to create slave %d: %d\n",
index, err);
ds->ports[index].netdev = NULL;
port->index, err);
port->netdev = NULL;
return err;
}
memset(&ds->ports[index].devlink_port, 0,
sizeof(ds->ports[index].devlink_port));
err = devlink_port_register(ds->devlink, &ds->ports[index].devlink_port,
index);
memset(&port->devlink_port, 0, sizeof(port->devlink_port));
err = devlink_port_register(ds->devlink, &port->devlink_port,
port->index);
if (err)
return err;
devlink_port_type_eth_set(&ds->ports[index].devlink_port,
ds->ports[index].netdev);
devlink_port_type_eth_set(&port->devlink_port, port->netdev);
return 0;
}
static void dsa_user_port_unapply(struct dsa_port *port, u32 index,
struct dsa_switch *ds)
static void dsa_user_port_unapply(struct dsa_port *port)
{
devlink_port_unregister(&ds->ports[index].devlink_port);
if (ds->ports[index].netdev) {
dsa_slave_destroy(ds->ports[index].netdev);
ds->ports[index].netdev = NULL;
ds->enabled_port_mask &= ~(1 << index);
devlink_port_unregister(&port->devlink_port);
if (port->netdev) {
dsa_slave_destroy(port->netdev);
port->netdev = NULL;
port->ds->enabled_port_mask &= ~(1 << port->index);
}
}
@ -370,20 +360,20 @@ static int dsa_ds_apply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
continue;
if (dsa_port_is_dsa(port)) {
err = dsa_dsa_port_apply(port, index, ds);
err = dsa_dsa_port_apply(port);
if (err)
return err;
continue;
}
if (dsa_port_is_cpu(port)) {
err = dsa_cpu_port_apply(port, index, ds);
err = dsa_cpu_port_apply(port);
if (err)
return err;
continue;
}
err = dsa_user_port_apply(port, index, ds);
err = dsa_user_port_apply(port);
if (err)
continue;
}
@ -402,16 +392,16 @@ static void dsa_ds_unapply(struct dsa_switch_tree *dst, struct dsa_switch *ds)
continue;
if (dsa_port_is_dsa(port)) {
dsa_dsa_port_unapply(port, index, ds);
dsa_dsa_port_unapply(port);
continue;
}
if (dsa_port_is_cpu(port)) {
dsa_cpu_port_unapply(port, index, ds);
dsa_cpu_port_unapply(port);
continue;
}
dsa_user_port_unapply(port, index, ds);
dsa_user_port_unapply(port);
}
if (ds->slave_mii_bus && ds->ops->phy_read)
@ -444,7 +434,7 @@ static int dsa_dst_apply(struct dsa_switch_tree *dst)
}
if (dst->cpu_dp) {
err = dsa_cpu_port_ethtool_setup(dst->cpu_dp->ds);
err = dsa_cpu_port_ethtool_setup(dst->cpu_dp);
if (err)
return err;
}
@ -485,7 +475,7 @@ static void dsa_dst_unapply(struct dsa_switch_tree *dst)
}
if (dst->cpu_dp)
dsa_cpu_port_ethtool_restore(dst->cpu_dp->ds);
dsa_cpu_port_ethtool_restore(dst->cpu_dp);
pr_info("DSA: tree %d unapplied\n", dst->tree);
dst->applied = false;
@ -530,6 +520,12 @@ static int dsa_cpu_parse(struct dsa_port *port, u32 index,
dst->rcv = dst->tag_ops->rcv;
/* Initialize cpu_port_mask now for drv->setup()
* to have access to a correct value, just like what
* net/dsa/dsa.c::dsa_switch_setup_one does.
*/
ds->cpu_port_mask |= BIT(index);
return 0;
}
@ -541,14 +537,22 @@ static int dsa_ds_parse(struct dsa_switch_tree *dst, struct dsa_switch *ds)
for (index = 0; index < ds->num_ports; index++) {
port = &ds->ports[index];
if (!dsa_port_is_valid(port))
if (!dsa_port_is_valid(port) ||
dsa_port_is_dsa(port))
continue;
if (dsa_port_is_cpu(port)) {
err = dsa_cpu_parse(port, index, dst, ds);
if (err)
return err;
} else {
/* Initialize enabled_port_mask now for drv->setup()
* to have access to a correct value, just like what
* net/dsa/dsa.c::dsa_switch_setup_one does.
*/
ds->enabled_port_mask |= BIT(index);
}
}
pr_info("DSA: switch %d %d parsed\n", dst->tree, ds->index);
@ -597,13 +601,6 @@ static int dsa_parse_ports_dn(struct device_node *ports, struct dsa_switch *ds)
return -EINVAL;
ds->ports[reg].dn = port;
/* Initialize enabled_port_mask now for ops->setup()
* to have access to a correct value, just like what
* net/dsa/dsa.c::dsa_switch_setup_one does.
*/
if (!dsa_port_is_cpu(&ds->ports[reg]))
ds->enabled_port_mask |= 1 << reg;
}
return 0;
@ -619,14 +616,6 @@ static int dsa_parse_ports(struct dsa_chip_data *cd, struct dsa_switch *ds)
continue;
ds->ports[i].name = cd->port_names[i];
/* Initialize enabled_port_mask now for drv->setup()
* to have access to a correct value, just like what
* net/dsa/dsa.c::dsa_switch_setup_one does.
*/
if (!dsa_port_is_cpu(&ds->ports[i]))
ds->enabled_port_mask |= 1 << i;
valid_name_found = true;
}

4
net/dsa/dsa_priv.h
View File

@ -103,8 +103,8 @@ int dsa_cpu_dsa_setup(struct dsa_switch *ds, struct device *dev,
struct dsa_port *dport, int port);
void dsa_cpu_dsa_destroy(struct dsa_port *dport);
const struct dsa_device_ops *dsa_resolve_tag_protocol(int tag_protocol);
int dsa_cpu_port_ethtool_setup(struct dsa_switch *ds);
void dsa_cpu_port_ethtool_restore(struct dsa_switch *ds);
int dsa_cpu_port_ethtool_setup(struct dsa_port *cpu_dp);
void dsa_cpu_port_ethtool_restore(struct dsa_port *cpu_dp);
/* legacy.c */
int dsa_legacy_register(void);

4
net/dsa/legacy.c
View File

@ -205,7 +205,7 @@ static int dsa_switch_setup_one(struct dsa_switch *ds, struct device *parent)
netdev_err(dst->master_netdev, "[%d] : can't configure CPU and DSA ports\n",
index);
ret = dsa_cpu_port_ethtool_setup(ds);
ret = dsa_cpu_port_ethtool_setup(ds->dst->cpu_dp);
if (ret)
return ret;
@ -733,7 +733,7 @@ static void dsa_remove_dst(struct dsa_switch_tree *dst)
dsa_switch_destroy(ds);
}
dsa_cpu_port_ethtool_restore(dst->cpu_dp->ds);
dsa_cpu_port_ethtool_restore(dst->cpu_dp);
dev_put(dst->master_netdev);
}