Skip to content

Commit

Permalink
Merge branch 'dsa-next'
Browse files Browse the repository at this point in the history 
Florian Fainelli says:

====================
net: dsa: code re-organization

This pull request contains the first part of the patches required to implement
the grand plan detailed here:

http://www.spinics.net/lists/netdev/msg295942.html

These are mostly code re-organization and function bodies re-arrangement to
allow different callers of lower-level initialization functions for 'struct
dsa_switch' and 'struct dsa_switch_tree' to be later introduced.

There is no functional code change at this point.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
  • Loading branch information
David S. Miller committed Mar 6, 2015
2 parents 4961272 + c86e59b commit 050f7dc
Show file tree
Hide file tree
Showing 2 changed files with 126 additions and 93 deletions.
5 changes: 5 additions & 0 deletions include/net/dsa.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -127,6 +127,11 @@ struct dsa_switch {
struct dsa_switch_tree *dst;
int index;

/*
* Tagging protocol understood by this switch
*/
enum dsa_tag_protocol tag_protocol;

/*
* Configuration data for this switch.
*/
Expand Down
214 changes: 121 additions & 93 deletions net/dsa/dsa.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -175,43 +175,14 @@ __ATTRIBUTE_GROUPS(dsa_hwmon);
#endif /* CONFIG_NET_DSA_HWMON */

/* basic switch operations **************************************************/
static struct dsa_switch *
dsa_switch_setup(struct dsa_switch_tree *dst, int index,
struct device *parent, struct device *host_dev)
static int dsa_switch_setup_one(struct dsa_switch *ds, struct device *parent)
{
struct dsa_chip_data *pd = dst->pd->chip + index;
struct dsa_switch_driver *drv;
struct dsa_switch *ds;
int ret;
char *name;
int i;
struct dsa_switch_driver *drv = ds->drv;
struct dsa_switch_tree *dst = ds->dst;
struct dsa_chip_data *pd = ds->pd;
bool valid_name_found = false;

/*
* Probe for switch model.
*/
drv = dsa_switch_probe(host_dev, pd->sw_addr, &name);
if (drv == NULL) {
netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n",
index);
return ERR_PTR(-EINVAL);
}
netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n",
index, name);


/*
* Allocate and initialise switch state.
*/
ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
if (ds == NULL)
return ERR_PTR(-ENOMEM);

ds->dst = dst;
ds->index = index;
ds->pd = dst->pd->chip + index;
ds->drv = drv;
ds->master_dev = host_dev;
int index = ds->index;
int i, ret;

/*
* Validate supplied switch configuration.
Expand Down Expand Up @@ -256,7 +227,7 @@ dsa_switch_setup(struct dsa_switch_tree *dst, int index,
* switch.
*/
if (dst->cpu_switch == index) {
switch (drv->tag_protocol) {
switch (ds->tag_protocol) {
#ifdef CONFIG_NET_DSA_TAG_DSA
case DSA_TAG_PROTO_DSA:
dst->rcv = dsa_netdev_ops.rcv;
Expand Down Expand Up @@ -284,7 +255,7 @@ dsa_switch_setup(struct dsa_switch_tree *dst, int index,
goto out;
}

dst->tag_protocol = drv->tag_protocol;
dst->tag_protocol = ds->tag_protocol;
}

/*
Expand Down Expand Up @@ -350,13 +321,57 @@ dsa_switch_setup(struct dsa_switch_tree *dst, int index,
}
#endif /* CONFIG_NET_DSA_HWMON */

return ds;
return ret;

out_free:
mdiobus_free(ds->slave_mii_bus);
out:
kfree(ds);
return ERR_PTR(ret);
return ret;
}

static struct dsa_switch *
dsa_switch_setup(struct dsa_switch_tree *dst, int index,
struct device *parent, struct device *host_dev)
{
struct dsa_chip_data *pd = dst->pd->chip + index;
struct dsa_switch_driver *drv;
struct dsa_switch *ds;
int ret;
char *name;

/*
* Probe for switch model.
*/
drv = dsa_switch_probe(host_dev, pd->sw_addr, &name);
if (drv == NULL) {
netdev_err(dst->master_netdev, "[%d]: could not detect attached switch\n",
index);
return ERR_PTR(-EINVAL);
}
netdev_info(dst->master_netdev, "[%d]: detected a %s switch\n",
index, name);


/*
* Allocate and initialise switch state.
*/
ds = kzalloc(sizeof(*ds) + drv->priv_size, GFP_KERNEL);
if (ds == NULL)
return NULL;

ds->dst = dst;
ds->index = index;
ds->pd = pd;
ds->drv = drv;
ds->tag_protocol = drv->tag_protocol;
ds->master_dev = host_dev;

ret = dsa_switch_setup_one(ds, parent);
if (ret)
return NULL;

return ds;
}

static void dsa_switch_destroy(struct dsa_switch *ds)
Expand Down Expand Up @@ -563,9 +578,9 @@ static void dsa_of_free_platform_data(struct dsa_platform_data *pd)
kfree(pd->chip);
}

static int dsa_of_probe(struct platform_device *pdev)
static int dsa_of_probe(struct device *dev)
{
struct device_node *np = pdev->dev.of_node;
struct device_node *np = dev->of_node;
struct device_node *child, *mdio, *ethernet, *port, *link;
struct mii_bus *mdio_bus;
struct platform_device *ethernet_dev;
Expand All @@ -583,21 +598,21 @@ static int dsa_of_probe(struct platform_device *pdev)

mdio_bus = of_mdio_find_bus(mdio);
if (!mdio_bus)
return -EINVAL;
return -EPROBE_DEFER;

ethernet = of_parse_phandle(np, "dsa,ethernet", 0);
if (!ethernet)
return -EINVAL;

ethernet_dev = of_find_device_by_node(ethernet);
if (!ethernet_dev)
return -ENODEV;
return -EPROBE_DEFER;

pd = kzalloc(sizeof(*pd), GFP_KERNEL);
if (!pd)
return -ENOMEM;

pdev->dev.platform_data = pd;
dev->platform_data = pd;
pd->netdev = &ethernet_dev->dev;
pd->nr_chips = of_get_available_child_count(np);
if (pd->nr_chips > DSA_MAX_SWITCHES)
Expand Down Expand Up @@ -670,43 +685,86 @@ static int dsa_of_probe(struct platform_device *pdev)
dsa_of_free_platform_data(pd);
out_free:
kfree(pd);
pdev->dev.platform_data = NULL;
dev->platform_data = NULL;
return ret;
}

static void dsa_of_remove(struct platform_device *pdev)
static void dsa_of_remove(struct device *dev)
{
struct dsa_platform_data *pd = pdev->dev.platform_data;
struct dsa_platform_data *pd = dev->platform_data;

if (!pdev->dev.of_node)
if (!dev->of_node)
return;

dsa_of_free_platform_data(pd);
kfree(pd);
}
#else
static inline int dsa_of_probe(struct platform_device *pdev)
static inline int dsa_of_probe(struct device *dev)
{
return 0;
}

static inline void dsa_of_remove(struct platform_device *pdev)
static inline void dsa_of_remove(struct device *dev)
{
}
#endif

static void dsa_setup_dst(struct dsa_switch_tree *dst, struct net_device *dev,
struct device *parent, struct dsa_platform_data *pd)
{
int i;

dst->pd = pd;
dst->master_netdev = dev;
dst->cpu_switch = -1;
dst->cpu_port = -1;

for (i = 0; i < pd->nr_chips; i++) {
struct dsa_switch *ds;

ds = dsa_switch_setup(dst, i, parent, pd->chip[i].host_dev);
if (IS_ERR(ds)) {
netdev_err(dev, "[%d]: couldn't create dsa switch instance (error %ld)\n",
i, PTR_ERR(ds));
continue;
}

dst->ds[i] = ds;
if (ds->drv->poll_link != NULL)
dst->link_poll_needed = 1;
}

/*
* If we use a tagging format that doesn't have an ethertype
* field, make sure that all packets from this point on get
* sent to the tag format's receive function.
*/
wmb();
dev->dsa_ptr = (void *)dst;

if (dst->link_poll_needed) {
INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
init_timer(&dst->link_poll_timer);
dst->link_poll_timer.data = (unsigned long)dst;
dst->link_poll_timer.function = dsa_link_poll_timer;
dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
add_timer(&dst->link_poll_timer);
}
}

static int dsa_probe(struct platform_device *pdev)
{
struct dsa_platform_data *pd = pdev->dev.platform_data;
struct net_device *dev;
struct dsa_switch_tree *dst;
int i, ret;
int ret;

pr_notice_once("Distributed Switch Architecture driver version %s\n",
dsa_driver_version);

if (pdev->dev.of_node) {
ret = dsa_of_probe(pdev);
ret = dsa_of_probe(&pdev->dev);
if (ret)
return ret;

Expand All @@ -718,7 +776,7 @@ static int dsa_probe(struct platform_device *pdev)

dev = dev_to_net_device(pd->netdev);
if (dev == NULL) {
ret = -EINVAL;
ret = -EPROBE_DEFER;
goto out;
}

Expand All @@ -737,54 +795,18 @@ static int dsa_probe(struct platform_device *pdev)

platform_set_drvdata(pdev, dst);

dst->pd = pd;
dst->master_netdev = dev;
dst->cpu_switch = -1;
dst->cpu_port = -1;

for (i = 0; i < pd->nr_chips; i++) {
struct dsa_switch *ds;

ds = dsa_switch_setup(dst, i, &pdev->dev, pd->chip[i].host_dev);
if (IS_ERR(ds)) {
netdev_err(dev, "[%d]: couldn't create dsa switch instance (error %ld)\n",
i, PTR_ERR(ds));
continue;
}

dst->ds[i] = ds;
if (ds->drv->poll_link != NULL)
dst->link_poll_needed = 1;
}

/*
* If we use a tagging format that doesn't have an ethertype
* field, make sure that all packets from this point on get
* sent to the tag format's receive function.
*/
wmb();
dev->dsa_ptr = (void *)dst;

if (dst->link_poll_needed) {
INIT_WORK(&dst->link_poll_work, dsa_link_poll_work);
init_timer(&dst->link_poll_timer);
dst->link_poll_timer.data = (unsigned long)dst;
dst->link_poll_timer.function = dsa_link_poll_timer;
dst->link_poll_timer.expires = round_jiffies(jiffies + HZ);
add_timer(&dst->link_poll_timer);
}
dsa_setup_dst(dst, dev, &pdev->dev, pd);

return 0;

out:
dsa_of_remove(pdev);
dsa_of_remove(&pdev->dev);

return ret;
}

static int dsa_remove(struct platform_device *pdev)
static void dsa_remove_dst(struct dsa_switch_tree *dst)
{
struct dsa_switch_tree *dst = platform_get_drvdata(pdev);
int i;

if (dst->link_poll_needed)
Expand All @@ -798,8 +820,14 @@ static int dsa_remove(struct platform_device *pdev)
if (ds != NULL)
dsa_switch_destroy(ds);
}
}

static int dsa_remove(struct platform_device *pdev)
{
struct dsa_switch_tree *dst = platform_get_drvdata(pdev);

dsa_of_remove(pdev);
dsa_remove_dst(dst);
dsa_of_remove(&pdev->dev);

return 0;
}
Expand Down

0 comments on commit 050f7dc

Please sign in to comment.