2019-05-27 13:55:01 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2017-05-20 04:00:44 +07:00
|
|
|
/*
|
|
|
|
|
* Handling of a single switch port
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2017 Savoir-faire Linux Inc.
|
|
|
|
|
* Vivien Didelot <vivien.didelot@savoirfairelinux.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/if_bridge.h>
|
2017-05-20 04:00:45 +07:00
|
|
|
#include <linux/notifier.h>
|
2017-10-26 21:50:07 +07:00
|
|
|
#include <linux/of_mdio.h>
|
|
|
|
|
#include <linux/of_net.h>
|
2017-05-20 04:00:44 +07:00
|
|
|
|
|
|
|
|
#include "dsa_priv.h"
|
|
|
|
|
|
2017-11-10 05:11:01 +07:00
|
|
|
static int dsa_port_notify(const struct dsa_port *dp, unsigned long e, void *v)
|
2017-05-20 04:00:45 +07:00
|
|
|
{
|
|
|
|
|
struct raw_notifier_head *nh = &dp->ds->dst->nh;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = raw_notifier_call_chain(nh, e, v);
|
|
|
|
|
|
|
|
|
|
return notifier_to_errno(err);
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 04:00:44 +07:00
|
|
|
int dsa_port_set_state(struct dsa_port *dp, u8 state,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
|
|
|
|
|
if (switchdev_trans_ph_prepare(trans))
|
|
|
|
|
return ds->ops->port_stp_state_set ? 0 : -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (ds->ops->port_stp_state_set)
|
|
|
|
|
ds->ops->port_stp_state_set(ds, port, state);
|
|
|
|
|
|
|
|
|
|
if (ds->ops->port_fast_age) {
|
|
|
|
|
/* Fast age FDB entries or flush appropriate forwarding database
|
|
|
|
|
* for the given port, if we are moving it from Learning or
|
|
|
|
|
* Forwarding state, to Disabled or Blocking or Listening state.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if ((dp->stp_state == BR_STATE_LEARNING ||
|
|
|
|
|
dp->stp_state == BR_STATE_FORWARDING) &&
|
|
|
|
|
(state == BR_STATE_DISABLED ||
|
|
|
|
|
state == BR_STATE_BLOCKING ||
|
|
|
|
|
state == BR_STATE_LISTENING))
|
|
|
|
|
ds->ops->port_fast_age(ds, port);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
dp->stp_state = state;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-23 06:01:56 +07:00
|
|
|
static void dsa_port_set_state_now(struct dsa_port *dp, u8 state)
|
2017-05-20 04:00:44 +07:00
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
err = dsa_port_set_state(dp, state, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
pr_err("DSA: failed to set STP state %u (%d)\n", state, err);
|
|
|
|
|
}
|
2017-05-20 04:00:45 +07:00
|
|
|
|
2020-03-03 22:01:46 +07:00
|
|
|
int dsa_port_enable_rt(struct dsa_port *dp, struct phy_device *phy)
|
2017-09-23 06:01:56 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (ds->ops->port_enable) {
|
|
|
|
|
err = ds->ops->port_enable(ds, port, phy);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-20 17:32:52 +07:00
|
|
|
if (!dp->bridge_dev)
|
|
|
|
|
dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
|
2017-09-23 06:01:56 +07:00
|
|
|
|
2020-03-03 22:01:46 +07:00
|
|
|
if (dp->pl)
|
|
|
|
|
phylink_start(dp->pl);
|
|
|
|
|
|
2017-09-23 06:01:56 +07:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-03 22:01:46 +07:00
|
|
|
int dsa_port_enable(struct dsa_port *dp, struct phy_device *phy)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
err = dsa_port_enable_rt(dp, phy);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void dsa_port_disable_rt(struct dsa_port *dp)
|
2017-09-23 06:01:56 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
|
2020-03-03 22:01:46 +07:00
|
|
|
if (dp->pl)
|
|
|
|
|
phylink_stop(dp->pl);
|
|
|
|
|
|
2019-02-20 17:32:52 +07:00
|
|
|
if (!dp->bridge_dev)
|
|
|
|
|
dsa_port_set_state_now(dp, BR_STATE_DISABLED);
|
2017-09-23 06:01:56 +07:00
|
|
|
|
|
|
|
|
if (ds->ops->port_disable)
|
2019-02-25 02:44:43 +07:00
|
|
|
ds->ops->port_disable(ds, port);
|
2017-09-23 06:01:56 +07:00
|
|
|
}
|
|
|
|
|
|
2020-03-03 22:01:46 +07:00
|
|
|
void dsa_port_disable(struct dsa_port *dp)
|
|
|
|
|
{
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
dsa_port_disable_rt(dp);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 04:00:45 +07:00
|
|
|
int dsa_port_bridge_join(struct dsa_port *dp, struct net_device *br)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_notifier_bridge_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.br = br,
|
|
|
|
|
};
|
|
|
|
|
int err;
|
|
|
|
|
|
net: dsa: enable flooding for bridge ports
Switches work by learning the MAC address for each attached station by
monitoring traffic from each station. When a station sends a packet,
the switch records which port the MAC address is connected to.
With IPv4 networking, before communication commences with a neighbour,
an ARP packet is broadcasted to all stations asking for the MAC address
corresponding with the IPv4. The desired station responds with an ARP
reply, and the ARP reply causes the switch to learn which port the
station is connected to.
With IPv6 networking, the situation is rather different. Rather than
broadcasting ARP packets, a "neighbour solicitation" is multicasted
rather than broadcasted. This multicast needs to reach the intended
station in order for the neighbour to be discovered.
Once a neighbour has been discovered, and entered into the sending
stations neighbour cache, communication can restart at a point later
without sending a new neighbour solicitation, even if the entry in
the neighbour cache is marked as stale. This can be after the MAC
address has expired from the forwarding cache of the DSA switch -
when that occurs, there is a long pause in communication.
Our DSA implementation for mv88e6xxx switches disables flooding of
multicast and unicast frames for bridged ports. As per the above
description, this is fine for IPv4 networking, since the broadcasted
ARP queries will be sent to and received by all stations on the same
network. However, this breaks IPv6 very badly - blocking neighbour
solicitations and later causing connections to stall.
The defaults that the Linux bridge code expect from bridges are for
unknown unicast and unknown multicast frames to be flooded to all ports
on the bridge, which is at odds to the defaults adopted by our DSA
implementation for mv88e6xxx switches.
This commit enables by default flooding of both unknown unicast and
unknown multicast frames whenever a port is added to a bridge, and
disables the flooding when a port leaves the bridge. This means that
mv88e6xxx DSA switches now behave as per the bridge(8) man page, and
IPv6 works flawlessly through such a switch.
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Reviewed-by: Vivien Didelot <vivien.didelot@gmail.com>
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-21 06:35:06 +07:00
|
|
|
/* Set the flooding mode before joining the port in the switch */
|
|
|
|
|
err = dsa_port_bridge_flags(dp, BR_FLOOD | BR_MCAST_FLOOD, NULL);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
/* Here the interface is already bridged. Reflect the current
|
|
|
|
|
* configuration so that drivers can program their chips accordingly.
|
2017-05-20 04:00:45 +07:00
|
|
|
*/
|
|
|
|
|
dp->bridge_dev = br;
|
|
|
|
|
|
|
|
|
|
err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_JOIN, &info);
|
|
|
|
|
|
|
|
|
|
/* The bridging is rolled back on error */
|
net: dsa: enable flooding for bridge ports
Switches work by learning the MAC address for each attached station by
monitoring traffic from each station. When a station sends a packet,
the switch records which port the MAC address is connected to.
With IPv4 networking, before communication commences with a neighbour,
an ARP packet is broadcasted to all stations asking for the MAC address
corresponding with the IPv4. The desired station responds with an ARP
reply, and the ARP reply causes the switch to learn which port the
station is connected to.
With IPv6 networking, the situation is rather different. Rather than
broadcasting ARP packets, a "neighbour solicitation" is multicasted
rather than broadcasted. This multicast needs to reach the intended
station in order for the neighbour to be discovered.
Once a neighbour has been discovered, and entered into the sending
stations neighbour cache, communication can restart at a point later
without sending a new neighbour solicitation, even if the entry in
the neighbour cache is marked as stale. This can be after the MAC
address has expired from the forwarding cache of the DSA switch -
when that occurs, there is a long pause in communication.
Our DSA implementation for mv88e6xxx switches disables flooding of
multicast and unicast frames for bridged ports. As per the above
description, this is fine for IPv4 networking, since the broadcasted
ARP queries will be sent to and received by all stations on the same
network. However, this breaks IPv6 very badly - blocking neighbour
solicitations and later causing connections to stall.
The defaults that the Linux bridge code expect from bridges are for
unknown unicast and unknown multicast frames to be flooded to all ports
on the bridge, which is at odds to the defaults adopted by our DSA
implementation for mv88e6xxx switches.
This commit enables by default flooding of both unknown unicast and
unknown multicast frames whenever a port is added to a bridge, and
disables the flooding when a port leaves the bridge. This means that
mv88e6xxx DSA switches now behave as per the bridge(8) man page, and
IPv6 works flawlessly through such a switch.
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Reviewed-by: Vivien Didelot <vivien.didelot@gmail.com>
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-21 06:35:06 +07:00
|
|
|
if (err) {
|
|
|
|
|
dsa_port_bridge_flags(dp, 0, NULL);
|
2017-05-20 04:00:45 +07:00
|
|
|
dp->bridge_dev = NULL;
|
net: dsa: enable flooding for bridge ports
Switches work by learning the MAC address for each attached station by
monitoring traffic from each station. When a station sends a packet,
the switch records which port the MAC address is connected to.
With IPv4 networking, before communication commences with a neighbour,
an ARP packet is broadcasted to all stations asking for the MAC address
corresponding with the IPv4. The desired station responds with an ARP
reply, and the ARP reply causes the switch to learn which port the
station is connected to.
With IPv6 networking, the situation is rather different. Rather than
broadcasting ARP packets, a "neighbour solicitation" is multicasted
rather than broadcasted. This multicast needs to reach the intended
station in order for the neighbour to be discovered.
Once a neighbour has been discovered, and entered into the sending
stations neighbour cache, communication can restart at a point later
without sending a new neighbour solicitation, even if the entry in
the neighbour cache is marked as stale. This can be after the MAC
address has expired from the forwarding cache of the DSA switch -
when that occurs, there is a long pause in communication.
Our DSA implementation for mv88e6xxx switches disables flooding of
multicast and unicast frames for bridged ports. As per the above
description, this is fine for IPv4 networking, since the broadcasted
ARP queries will be sent to and received by all stations on the same
network. However, this breaks IPv6 very badly - blocking neighbour
solicitations and later causing connections to stall.
The defaults that the Linux bridge code expect from bridges are for
unknown unicast and unknown multicast frames to be flooded to all ports
on the bridge, which is at odds to the defaults adopted by our DSA
implementation for mv88e6xxx switches.
This commit enables by default flooding of both unknown unicast and
unknown multicast frames whenever a port is added to a bridge, and
disables the flooding when a port leaves the bridge. This means that
mv88e6xxx DSA switches now behave as per the bridge(8) man page, and
IPv6 works flawlessly through such a switch.
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Reviewed-by: Vivien Didelot <vivien.didelot@gmail.com>
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-21 06:35:06 +07:00
|
|
|
}
|
2017-05-20 04:00:45 +07:00
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void dsa_port_bridge_leave(struct dsa_port *dp, struct net_device *br)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_notifier_bridge_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.br = br,
|
|
|
|
|
};
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
/* Here the port is already unbridged. Reflect the current configuration
|
|
|
|
|
* so that drivers can program their chips accordingly.
|
|
|
|
|
*/
|
|
|
|
|
dp->bridge_dev = NULL;
|
|
|
|
|
|
|
|
|
|
err = dsa_port_notify(dp, DSA_NOTIFIER_BRIDGE_LEAVE, &info);
|
|
|
|
|
if (err)
|
|
|
|
|
pr_err("DSA: failed to notify DSA_NOTIFIER_BRIDGE_LEAVE\n");
|
|
|
|
|
|
net: dsa: enable flooding for bridge ports
Switches work by learning the MAC address for each attached station by
monitoring traffic from each station. When a station sends a packet,
the switch records which port the MAC address is connected to.
With IPv4 networking, before communication commences with a neighbour,
an ARP packet is broadcasted to all stations asking for the MAC address
corresponding with the IPv4. The desired station responds with an ARP
reply, and the ARP reply causes the switch to learn which port the
station is connected to.
With IPv6 networking, the situation is rather different. Rather than
broadcasting ARP packets, a "neighbour solicitation" is multicasted
rather than broadcasted. This multicast needs to reach the intended
station in order for the neighbour to be discovered.
Once a neighbour has been discovered, and entered into the sending
stations neighbour cache, communication can restart at a point later
without sending a new neighbour solicitation, even if the entry in
the neighbour cache is marked as stale. This can be after the MAC
address has expired from the forwarding cache of the DSA switch -
when that occurs, there is a long pause in communication.
Our DSA implementation for mv88e6xxx switches disables flooding of
multicast and unicast frames for bridged ports. As per the above
description, this is fine for IPv4 networking, since the broadcasted
ARP queries will be sent to and received by all stations on the same
network. However, this breaks IPv6 very badly - blocking neighbour
solicitations and later causing connections to stall.
The defaults that the Linux bridge code expect from bridges are for
unknown unicast and unknown multicast frames to be flooded to all ports
on the bridge, which is at odds to the defaults adopted by our DSA
implementation for mv88e6xxx switches.
This commit enables by default flooding of both unknown unicast and
unknown multicast frames whenever a port is added to a bridge, and
disables the flooding when a port leaves the bridge. This means that
mv88e6xxx DSA switches now behave as per the bridge(8) man page, and
IPv6 works flawlessly through such a switch.
Reviewed-by: Florian Fainelli <f.fainelli@gmail.com>
Reviewed-by: Vivien Didelot <vivien.didelot@gmail.com>
Signed-off-by: Russell King <rmk+kernel@armlinux.org.uk>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-21 06:35:06 +07:00
|
|
|
/* Port is leaving the bridge, disable flooding */
|
|
|
|
|
dsa_port_bridge_flags(dp, 0, NULL);
|
|
|
|
|
|
2017-05-20 04:00:45 +07:00
|
|
|
/* Port left the bridge, put in BR_STATE_DISABLED by the bridge layer,
|
|
|
|
|
* so allow it to be in BR_STATE_FORWARDING to be kept functional
|
|
|
|
|
*/
|
|
|
|
|
dsa_port_set_state_now(dp, BR_STATE_FORWARDING);
|
|
|
|
|
}
|
2017-05-20 04:00:46 +07:00
|
|
|
|
2019-04-29 01:45:44 +07:00
|
|
|
static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
|
|
|
|
|
bool vlan_filtering)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (!ds->vlan_filtering_is_global)
|
|
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
/* For cases where enabling/disabling VLAN awareness is global to the
|
|
|
|
|
* switch, we need to handle the case where multiple bridges span
|
|
|
|
|
* different ports of the same switch device and one of them has a
|
|
|
|
|
* different setting than what is being requested.
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < ds->num_ports; i++) {
|
|
|
|
|
struct net_device *other_bridge;
|
|
|
|
|
|
|
|
|
|
other_bridge = dsa_to_port(ds, i)->bridge_dev;
|
|
|
|
|
if (!other_bridge)
|
|
|
|
|
continue;
|
|
|
|
|
/* If it's the same bridge, it also has same
|
|
|
|
|
* vlan_filtering setting => no need to check
|
|
|
|
|
*/
|
|
|
|
|
if (other_bridge == dp->bridge_dev)
|
|
|
|
|
continue;
|
|
|
|
|
if (br_vlan_enabled(other_bridge) != vlan_filtering) {
|
|
|
|
|
dev_err(ds->dev, "VLAN filtering is a global setting\n");
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-20 04:00:46 +07:00
|
|
|
int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
2019-04-29 01:45:43 +07:00
|
|
|
int err;
|
2017-05-20 04:00:46 +07:00
|
|
|
|
|
|
|
|
/* bridge skips -EOPNOTSUPP, so skip the prepare phase */
|
|
|
|
|
if (switchdev_trans_ph_prepare(trans))
|
|
|
|
|
return 0;
|
|
|
|
|
|
2019-04-29 01:45:44 +07:00
|
|
|
if (!ds->ops->port_vlan_filtering)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (!dsa_port_can_apply_vlan_filtering(dp, vlan_filtering))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2019-04-29 01:45:51 +07:00
|
|
|
if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2019-04-29 01:45:44 +07:00
|
|
|
err = ds->ops->port_vlan_filtering(ds, dp->index,
|
|
|
|
|
vlan_filtering);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2019-04-29 01:45:48 +07:00
|
|
|
if (ds->vlan_filtering_is_global)
|
|
|
|
|
ds->vlan_filtering = vlan_filtering;
|
|
|
|
|
else
|
|
|
|
|
dp->vlan_filtering = vlan_filtering;
|
2017-05-20 04:00:46 +07:00
|
|
|
return 0;
|
|
|
|
|
}
|
2017-05-20 04:00:47 +07:00
|
|
|
|
|
|
|
|
int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
|
|
|
|
unsigned long ageing_jiffies = clock_t_to_jiffies(ageing_clock);
|
|
|
|
|
unsigned int ageing_time = jiffies_to_msecs(ageing_jiffies);
|
2017-05-20 04:00:52 +07:00
|
|
|
struct dsa_notifier_ageing_time_info info = {
|
|
|
|
|
.ageing_time = ageing_time,
|
|
|
|
|
.trans = trans,
|
|
|
|
|
};
|
2017-05-20 04:00:47 +07:00
|
|
|
|
2017-05-20 04:00:52 +07:00
|
|
|
if (switchdev_trans_ph_prepare(trans))
|
|
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
|
2017-05-20 04:00:47 +07:00
|
|
|
|
|
|
|
|
dp->ageing_time = ageing_time;
|
|
|
|
|
|
2017-05-20 04:00:52 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_AGEING_TIME, &info);
|
2017-05-20 04:00:47 +07:00
|
|
|
}
|
2017-05-20 04:00:48 +07:00
|
|
|
|
2019-02-21 07:58:22 +07:00
|
|
|
int dsa_port_pre_bridge_flags(const struct dsa_port *dp, unsigned long flags,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
|
|
|
|
if (!ds->ops->port_egress_floods ||
|
|
|
|
|
(flags & ~(BR_FLOOD | BR_MCAST_FLOOD)))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-21 06:35:04 +07:00
|
|
|
int dsa_port_bridge_flags(const struct dsa_port *dp, unsigned long flags,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
if (switchdev_trans_ph_prepare(trans))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (ds->ops->port_egress_floods)
|
|
|
|
|
err = ds->ops->port_egress_floods(ds, port, flags & BR_FLOOD,
|
|
|
|
|
flags & BR_MCAST_FLOOD);
|
|
|
|
|
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-09 10:31:13 +07:00
|
|
|
int dsa_port_mrouter(struct dsa_port *dp, bool mrouter,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
|
|
|
|
|
if (switchdev_trans_ph_prepare(trans))
|
|
|
|
|
return ds->ops->port_egress_floods ? 0 : -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
return ds->ops->port_egress_floods(ds, port, true, mrouter);
|
|
|
|
|
}
|
|
|
|
|
|
net: dsa: configure the MTU for switch ports
It is useful be able to configure port policers on a switch to accept
frames of various sizes:
- Increase the MTU for better throughput from the default of 1500 if it
is known that there is no 10/100 Mbps device in the network.
- Decrease the MTU to limit the latency of high-priority frames under
congestion, or work around various network segments that add extra
headers to packets which can't be fragmented.
For DSA slave ports, this is mostly a pass-through callback, called
through the regular ndo ops and at probe time (to ensure consistency
across all supported switches).
The CPU port is called with an MTU equal to the largest configured MTU
of the slave ports. The assumption is that the user might want to
sustain a bidirectional conversation with a partner over any switch
port.
The DSA master is configured the same as the CPU port, plus the tagger
overhead. Since the MTU is by definition L2 payload (sans Ethernet
header), it is up to each individual driver to figure out if it needs to
do anything special for its frame tags on the CPU port (it shouldn't
except in special cases). So the MTU does not contain the tagger
overhead on the CPU port.
However the MTU of the DSA master, minus the tagger overhead, is used as
a proxy for the MTU of the CPU port, which does not have a net device.
This is to avoid uselessly calling the .change_mtu function on the CPU
port when nothing should change.
So it is safe to assume that the DSA master and the CPU port MTUs are
apart by exactly the tagger's overhead in bytes.
Some changes were made around dsa_master_set_mtu(), function which was
now removed, for 2 reasons:
- dev_set_mtu() already calls dev_validate_mtu(), so it's redundant to
do the same thing in DSA
- __dev_set_mtu() returns 0 if ops->ndo_change_mtu is an absent method
That is to say, there's no need for this function in DSA, we can safely
call dev_set_mtu() directly, take the rtnl lock when necessary, and just
propagate whatever errors get reported (since the user probably wants to
be informed).
Some inspiration (mainly in the MTU DSA notifier) was taken from a
vaguely similar patch from Murali and Florian, who are credited as
co-developers down below.
Co-developed-by: Murali Krishna Policharla <murali.policharla@broadcom.com>
Signed-off-by: Murali Krishna Policharla <murali.policharla@broadcom.com>
Co-developed-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: Florian Fainelli <f.fainelli@gmail.com>
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-03-28 02:55:42 +07:00
|
|
|
int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
|
|
|
|
|
bool propagate_upstream)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_notifier_mtu_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.propagate_upstream = propagate_upstream,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.mtu = new_mtu,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_MTU, &info);
|
|
|
|
|
}
|
|
|
|
|
|
2017-08-06 20:15:41 +07:00
|
|
|
int dsa_port_fdb_add(struct dsa_port *dp, const unsigned char *addr,
|
|
|
|
|
u16 vid)
|
2017-05-20 04:00:48 +07:00
|
|
|
{
|
2017-05-20 04:00:53 +07:00
|
|
|
struct dsa_notifier_fdb_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
2017-08-06 20:15:41 +07:00
|
|
|
.addr = addr,
|
|
|
|
|
.vid = vid,
|
2017-05-20 04:00:53 +07:00
|
|
|
};
|
2017-05-20 04:00:48 +07:00
|
|
|
|
2017-05-20 04:00:53 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_FDB_ADD, &info);
|
2017-05-20 04:00:48 +07:00
|
|
|
}
|
|
|
|
|
|
2017-08-06 20:15:41 +07:00
|
|
|
int dsa_port_fdb_del(struct dsa_port *dp, const unsigned char *addr,
|
|
|
|
|
u16 vid)
|
2017-05-20 04:00:48 +07:00
|
|
|
{
|
2017-05-20 04:00:53 +07:00
|
|
|
struct dsa_notifier_fdb_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
2017-08-06 20:15:41 +07:00
|
|
|
.addr = addr,
|
|
|
|
|
.vid = vid,
|
|
|
|
|
|
2017-05-20 04:00:53 +07:00
|
|
|
};
|
2017-05-20 04:00:48 +07:00
|
|
|
|
2017-05-20 04:00:53 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_FDB_DEL, &info);
|
2017-05-20 04:00:48 +07:00
|
|
|
}
|
|
|
|
|
|
2017-09-21 06:32:14 +07:00
|
|
|
int dsa_port_fdb_dump(struct dsa_port *dp, dsa_fdb_dump_cb_t *cb, void *data)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
|
|
|
|
|
if (!ds->ops->port_fdb_dump)
|
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
return ds->ops->port_fdb_dump(ds, port, cb, data);
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-10 05:11:01 +07:00
|
|
|
int dsa_port_mdb_add(const struct dsa_port *dp,
|
2017-05-20 04:00:49 +07:00
|
|
|
const struct switchdev_obj_port_mdb *mdb,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
2017-05-20 04:00:54 +07:00
|
|
|
struct dsa_notifier_mdb_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.trans = trans,
|
|
|
|
|
.mdb = mdb,
|
|
|
|
|
};
|
2017-05-20 04:00:49 +07:00
|
|
|
|
2017-05-20 04:00:54 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_MDB_ADD, &info);
|
2017-05-20 04:00:49 +07:00
|
|
|
}
|
|
|
|
|
|
2017-11-10 05:11:01 +07:00
|
|
|
int dsa_port_mdb_del(const struct dsa_port *dp,
|
2017-05-20 04:00:49 +07:00
|
|
|
const struct switchdev_obj_port_mdb *mdb)
|
|
|
|
|
{
|
2017-05-20 04:00:54 +07:00
|
|
|
struct dsa_notifier_mdb_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.mdb = mdb,
|
|
|
|
|
};
|
2017-05-20 04:00:49 +07:00
|
|
|
|
2017-05-20 04:00:54 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_MDB_DEL, &info);
|
2017-05-20 04:00:49 +07:00
|
|
|
}
|
|
|
|
|
|
2017-05-20 04:00:50 +07:00
|
|
|
int dsa_port_vlan_add(struct dsa_port *dp,
|
|
|
|
|
const struct switchdev_obj_port_vlan *vlan,
|
|
|
|
|
struct switchdev_trans *trans)
|
|
|
|
|
{
|
2017-05-20 04:00:55 +07:00
|
|
|
struct dsa_notifier_vlan_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.trans = trans,
|
|
|
|
|
.vlan = vlan,
|
|
|
|
|
};
|
2017-05-20 04:00:50 +07:00
|
|
|
|
2019-08-26 00:25:18 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_ADD, &info);
|
2017-05-20 04:00:50 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int dsa_port_vlan_del(struct dsa_port *dp,
|
|
|
|
|
const struct switchdev_obj_port_vlan *vlan)
|
|
|
|
|
{
|
2017-05-20 04:00:55 +07:00
|
|
|
struct dsa_notifier_vlan_info info = {
|
|
|
|
|
.sw_index = dp->ds->index,
|
|
|
|
|
.port = dp->index,
|
|
|
|
|
.vlan = vlan,
|
|
|
|
|
};
|
2017-05-20 04:00:50 +07:00
|
|
|
|
2019-08-26 00:25:18 +07:00
|
|
|
return dsa_port_notify(dp, DSA_NOTIFIER_VLAN_DEL, &info);
|
2017-05-20 04:00:50 +07:00
|
|
|
}
|
2017-10-26 21:50:07 +07:00
|
|
|
|
2019-04-29 01:45:54 +07:00
|
|
|
int dsa_port_vid_add(struct dsa_port *dp, u16 vid, u16 flags)
|
|
|
|
|
{
|
|
|
|
|
struct switchdev_obj_port_vlan vlan = {
|
|
|
|
|
.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
|
|
|
|
|
.flags = flags,
|
|
|
|
|
.vid_begin = vid,
|
|
|
|
|
.vid_end = vid,
|
|
|
|
|
};
|
|
|
|
|
struct switchdev_trans trans;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
trans.ph_prepare = true;
|
|
|
|
|
err = dsa_port_vlan_add(dp, &vlan, &trans);
|
2019-08-26 00:25:16 +07:00
|
|
|
if (err)
|
|
|
|
|
return err;
|
2019-04-29 01:45:54 +07:00
|
|
|
|
|
|
|
|
trans.ph_prepare = false;
|
|
|
|
|
return dsa_port_vlan_add(dp, &vlan, &trans);
|
|
|
|
|
}
|
2019-05-05 17:19:21 +07:00
|
|
|
EXPORT_SYMBOL(dsa_port_vid_add);
|
2019-04-29 01:45:54 +07:00
|
|
|
|
|
|
|
|
int dsa_port_vid_del(struct dsa_port *dp, u16 vid)
|
|
|
|
|
{
|
|
|
|
|
struct switchdev_obj_port_vlan vlan = {
|
|
|
|
|
.obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN,
|
|
|
|
|
.vid_begin = vid,
|
|
|
|
|
.vid_end = vid,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return dsa_port_vlan_del(dp, &vlan);
|
|
|
|
|
}
|
2019-05-05 17:19:21 +07:00
|
|
|
EXPORT_SYMBOL(dsa_port_vid_del);
|
2019-04-29 01:45:54 +07:00
|
|
|
|
2018-04-26 02:12:51 +07:00
|
|
|
static struct phy_device *dsa_port_get_phy_device(struct dsa_port *dp)
|
2018-01-23 22:03:46 +07:00
|
|
|
{
|
|
|
|
|
struct device_node *phy_dn;
|
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
|
2018-04-26 02:12:51 +07:00
|
|
|
phy_dn = of_parse_phandle(dp->dn, "phy-handle", 0);
|
2018-01-23 22:03:46 +07:00
|
|
|
if (!phy_dn)
|
2018-04-26 02:12:51 +07:00
|
|
|
return NULL;
|
2018-01-23 22:03:46 +07:00
|
|
|
|
|
|
|
|
phydev = of_phy_find_device(phy_dn);
|
|
|
|
|
if (!phydev) {
|
2018-04-26 02:12:51 +07:00
|
|
|
of_node_put(phy_dn);
|
|
|
|
|
return ERR_PTR(-EPROBE_DEFER);
|
2018-01-23 22:03:46 +07:00
|
|
|
}
|
|
|
|
|
|
2019-02-25 14:22:19 +07:00
|
|
|
of_node_put(phy_dn);
|
2018-04-26 02:12:51 +07:00
|
|
|
return phydev;
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 01:32:47 +07:00
|
|
|
static void dsa_port_phylink_validate(struct phylink_config *config,
|
|
|
|
|
unsigned long *supported,
|
|
|
|
|
struct phylink_link_state *state)
|
2019-05-29 00:38:15 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
|
|
|
|
if (!ds->ops->phylink_validate)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ds->ops->phylink_validate(ds, dp->index, supported, state);
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 01:32:47 +07:00
|
|
|
static void dsa_port_phylink_mac_pcs_get_state(struct phylink_config *config,
|
|
|
|
|
struct phylink_link_state *state)
|
2019-05-29 00:38:15 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
2020-03-14 17:15:28 +07:00
|
|
|
int err;
|
2019-05-29 00:38:15 +07:00
|
|
|
|
2019-11-21 07:36:22 +07:00
|
|
|
/* Only called for inband modes */
|
|
|
|
|
if (!ds->ops->phylink_mac_link_state) {
|
|
|
|
|
state->link = 0;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2019-05-29 00:38:15 +07:00
|
|
|
|
2020-03-14 17:15:28 +07:00
|
|
|
err = ds->ops->phylink_mac_link_state(ds, dp->index, state);
|
|
|
|
|
if (err < 0) {
|
|
|
|
|
dev_err(ds->dev, "p%d: phylink_mac_link_state() failed: %d\n",
|
|
|
|
|
dp->index, err);
|
2019-11-21 07:36:22 +07:00
|
|
|
state->link = 0;
|
2020-03-14 17:15:28 +07:00
|
|
|
}
|
2019-05-29 00:38:15 +07:00
|
|
|
}
|
|
|
|
|
|
2019-12-17 01:32:47 +07:00
|
|
|
static void dsa_port_phylink_mac_config(struct phylink_config *config,
|
|
|
|
|
unsigned int mode,
|
|
|
|
|
const struct phylink_link_state *state)
|
2019-05-29 00:38:15 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
|
|
|
|
if (!ds->ops->phylink_mac_config)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ds->ops->phylink_mac_config(ds, dp->index, mode, state);
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 01:32:47 +07:00
|
|
|
static void dsa_port_phylink_mac_an_restart(struct phylink_config *config)
|
2019-05-29 00:38:15 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
|
|
|
|
if (!ds->ops->phylink_mac_an_restart)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ds->ops->phylink_mac_an_restart(ds, dp->index);
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 01:32:47 +07:00
|
|
|
static void dsa_port_phylink_mac_link_down(struct phylink_config *config,
|
|
|
|
|
unsigned int mode,
|
|
|
|
|
phy_interface_t interface)
|
2019-05-29 00:38:15 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
|
2019-05-29 00:38:16 +07:00
|
|
|
struct phy_device *phydev = NULL;
|
2019-05-29 00:38:15 +07:00
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
2019-05-29 00:38:16 +07:00
|
|
|
if (dsa_is_user_port(ds, dp->index))
|
|
|
|
|
phydev = dp->slave->phydev;
|
|
|
|
|
|
2019-05-29 00:38:15 +07:00
|
|
|
if (!ds->ops->phylink_mac_link_down) {
|
2019-05-29 00:38:16 +07:00
|
|
|
if (ds->ops->adjust_link && phydev)
|
|
|
|
|
ds->ops->adjust_link(ds, dp->index, phydev);
|
2019-05-29 00:38:15 +07:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-17 01:32:47 +07:00
|
|
|
static void dsa_port_phylink_mac_link_up(struct phylink_config *config,
|
2020-02-26 17:23:41 +07:00
|
|
|
struct phy_device *phydev,
|
2019-12-17 01:32:47 +07:00
|
|
|
unsigned int mode,
|
|
|
|
|
phy_interface_t interface,
|
2020-02-26 17:23:41 +07:00
|
|
|
int speed, int duplex,
|
|
|
|
|
bool tx_pause, bool rx_pause)
|
2019-05-29 00:38:15 +07:00
|
|
|
{
|
|
|
|
|
struct dsa_port *dp = container_of(config, struct dsa_port, pl_config);
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
|
|
|
|
if (!ds->ops->phylink_mac_link_up) {
|
2019-05-29 00:38:16 +07:00
|
|
|
if (ds->ops->adjust_link && phydev)
|
|
|
|
|
ds->ops->adjust_link(ds, dp->index, phydev);
|
2019-05-29 00:38:15 +07:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2020-02-26 17:23:46 +07:00
|
|
|
ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev,
|
|
|
|
|
speed, duplex, tx_pause, rx_pause);
|
2019-05-29 00:38:15 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const struct phylink_mac_ops dsa_port_phylink_mac_ops = {
|
|
|
|
|
.validate = dsa_port_phylink_validate,
|
2019-11-21 07:36:22 +07:00
|
|
|
.mac_pcs_get_state = dsa_port_phylink_mac_pcs_get_state,
|
2019-05-29 00:38:15 +07:00
|
|
|
.mac_config = dsa_port_phylink_mac_config,
|
|
|
|
|
.mac_an_restart = dsa_port_phylink_mac_an_restart,
|
|
|
|
|
.mac_link_down = dsa_port_phylink_mac_link_down,
|
|
|
|
|
.mac_link_up = dsa_port_phylink_mac_link_up,
|
|
|
|
|
};
|
|
|
|
|
|
2018-04-26 02:12:51 +07:00
|
|
|
static int dsa_port_setup_phy_of(struct dsa_port *dp, bool enable)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
int port = dp->index;
|
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
|
|
phydev = dsa_port_get_phy_device(dp);
|
|
|
|
|
if (!phydev)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
if (IS_ERR(phydev))
|
|
|
|
|
return PTR_ERR(phydev);
|
|
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
if (enable) {
|
|
|
|
|
err = genphy_resume(phydev);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto err_put_dev;
|
|
|
|
|
|
|
|
|
|
err = genphy_read_status(phydev);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto err_put_dev;
|
|
|
|
|
} else {
|
|
|
|
|
err = genphy_suspend(phydev);
|
|
|
|
|
if (err < 0)
|
|
|
|
|
goto err_put_dev;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ds->ops->adjust_link)
|
|
|
|
|
ds->ops->adjust_link(ds, port, phydev);
|
|
|
|
|
|
|
|
|
|
dev_dbg(ds->dev, "enabled port's phy: %s", phydev_name(phydev));
|
|
|
|
|
|
|
|
|
|
err_put_dev:
|
|
|
|
|
put_device(&phydev->mdio.dev);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int dsa_port_fixed_link_register_of(struct dsa_port *dp)
|
2017-10-26 21:50:07 +07:00
|
|
|
{
|
|
|
|
|
struct device_node *dn = dp->dn;
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
int port = dp->index;
|
net: of_get_phy_mode: Change API to solve int/unit warnings
Before this change of_get_phy_mode() returned an enum,
phy_interface_t. On error, -ENODEV etc, is returned. If the result of
the function is stored in a variable of type phy_interface_t, and the
compiler has decided to represent this as an unsigned int, comparision
with -ENODEV etc, is a signed vs unsigned comparision.
Fix this problem by changing the API. Make the function return an
error, or 0 on success, and pass a pointer, of type phy_interface_t,
where the phy mode should be stored.
v2:
Return with *interface set to PHY_INTERFACE_MODE_NA on error.
Add error checks to all users of of_get_phy_mode()
Fixup a few reverse christmas tree errors
Fixup a few slightly malformed reverse christmas trees
v3:
Fix 0-day reported errors.
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-04 08:40:33 +07:00
|
|
|
phy_interface_t mode;
|
2017-10-26 21:50:07 +07:00
|
|
|
int err;
|
|
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
err = of_phy_register_fixed_link(dn);
|
|
|
|
|
if (err) {
|
|
|
|
|
dev_err(ds->dev,
|
|
|
|
|
"failed to register the fixed PHY of port %d\n",
|
|
|
|
|
port);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
2017-10-26 21:50:07 +07:00
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
phydev = of_phy_find_device(dn);
|
2017-10-26 21:50:07 +07:00
|
|
|
|
net: of_get_phy_mode: Change API to solve int/unit warnings
Before this change of_get_phy_mode() returned an enum,
phy_interface_t. On error, -ENODEV etc, is returned. If the result of
the function is stored in a variable of type phy_interface_t, and the
compiler has decided to represent this as an unsigned int, comparision
with -ENODEV etc, is a signed vs unsigned comparision.
Fix this problem by changing the API. Make the function return an
error, or 0 on success, and pass a pointer, of type phy_interface_t,
where the phy mode should be stored.
v2:
Return with *interface set to PHY_INTERFACE_MODE_NA on error.
Add error checks to all users of of_get_phy_mode()
Fixup a few reverse christmas tree errors
Fixup a few slightly malformed reverse christmas trees
v3:
Fix 0-day reported errors.
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-04 08:40:33 +07:00
|
|
|
err = of_get_phy_mode(dn, &mode);
|
|
|
|
|
if (err)
|
2018-01-23 22:03:46 +07:00
|
|
|
mode = PHY_INTERFACE_MODE_NA;
|
|
|
|
|
phydev->interface = mode;
|
2017-10-26 21:50:07 +07:00
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
genphy_read_status(phydev);
|
2017-10-26 21:50:07 +07:00
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
if (ds->ops->adjust_link)
|
|
|
|
|
ds->ops->adjust_link(ds, port, phydev);
|
2017-10-26 21:50:07 +07:00
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
put_device(&phydev->mdio.dev);
|
2017-10-26 21:50:07 +07:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-29 00:38:16 +07:00
|
|
|
static int dsa_port_phylink_register(struct dsa_port *dp)
|
|
|
|
|
{
|
|
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
struct device_node *port_dn = dp->dn;
|
net: of_get_phy_mode: Change API to solve int/unit warnings
Before this change of_get_phy_mode() returned an enum,
phy_interface_t. On error, -ENODEV etc, is returned. If the result of
the function is stored in a variable of type phy_interface_t, and the
compiler has decided to represent this as an unsigned int, comparision
with -ENODEV etc, is a signed vs unsigned comparision.
Fix this problem by changing the API. Make the function return an
error, or 0 on success, and pass a pointer, of type phy_interface_t,
where the phy mode should be stored.
v2:
Return with *interface set to PHY_INTERFACE_MODE_NA on error.
Add error checks to all users of of_get_phy_mode()
Fixup a few reverse christmas tree errors
Fixup a few slightly malformed reverse christmas trees
v3:
Fix 0-day reported errors.
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-04 08:40:33 +07:00
|
|
|
phy_interface_t mode;
|
|
|
|
|
int err;
|
2019-05-29 00:38:16 +07:00
|
|
|
|
net: of_get_phy_mode: Change API to solve int/unit warnings
Before this change of_get_phy_mode() returned an enum,
phy_interface_t. On error, -ENODEV etc, is returned. If the result of
the function is stored in a variable of type phy_interface_t, and the
compiler has decided to represent this as an unsigned int, comparision
with -ENODEV etc, is a signed vs unsigned comparision.
Fix this problem by changing the API. Make the function return an
error, or 0 on success, and pass a pointer, of type phy_interface_t,
where the phy mode should be stored.
v2:
Return with *interface set to PHY_INTERFACE_MODE_NA on error.
Add error checks to all users of of_get_phy_mode()
Fixup a few reverse christmas tree errors
Fixup a few slightly malformed reverse christmas trees
v3:
Fix 0-day reported errors.
Reported-by: Dan Carpenter <dan.carpenter@oracle.com>
Signed-off-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-04 08:40:33 +07:00
|
|
|
err = of_get_phy_mode(port_dn, &mode);
|
|
|
|
|
if (err)
|
2019-05-29 00:38:16 +07:00
|
|
|
mode = PHY_INTERFACE_MODE_NA;
|
|
|
|
|
|
|
|
|
|
dp->pl_config.dev = ds->dev;
|
|
|
|
|
dp->pl_config.type = PHYLINK_DEV;
|
2020-01-06 08:34:12 +07:00
|
|
|
dp->pl_config.pcs_poll = ds->pcs_poll;
|
2019-05-29 00:38:16 +07:00
|
|
|
|
|
|
|
|
dp->pl = phylink_create(&dp->pl_config, of_fwnode_handle(port_dn),
|
|
|
|
|
mode, &dsa_port_phylink_mac_ops);
|
|
|
|
|
if (IS_ERR(dp->pl)) {
|
|
|
|
|
pr_err("error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
|
|
|
|
|
return PTR_ERR(dp->pl);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err = phylink_of_phy_connect(dp->pl, port_dn, 0);
|
2019-06-11 02:31:49 +07:00
|
|
|
if (err && err != -ENODEV) {
|
2019-05-29 00:38:16 +07:00
|
|
|
pr_err("could not attach to PHY: %d\n", err);
|
|
|
|
|
goto err_phy_connect;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
err_phy_connect:
|
|
|
|
|
phylink_destroy(dp->pl);
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
int dsa_port_link_register_of(struct dsa_port *dp)
|
2017-10-26 21:50:07 +07:00
|
|
|
{
|
2019-05-29 00:38:16 +07:00
|
|
|
struct dsa_switch *ds = dp->ds;
|
2020-03-11 22:24:24 +07:00
|
|
|
struct device_node *phy_np;
|
2020-04-14 07:34:39 +07:00
|
|
|
int port = dp->index;
|
2019-05-29 00:38:16 +07:00
|
|
|
|
2020-03-11 22:24:24 +07:00
|
|
|
if (!ds->ops->adjust_link) {
|
|
|
|
|
phy_np = of_parse_phandle(dp->dn, "phy-handle", 0);
|
2020-04-14 07:34:39 +07:00
|
|
|
if (of_phy_is_fixed_link(dp->dn) || phy_np) {
|
|
|
|
|
if (ds->ops->phylink_mac_link_down)
|
|
|
|
|
ds->ops->phylink_mac_link_down(ds, port,
|
|
|
|
|
MLO_AN_FIXED, PHY_INTERFACE_MODE_NA);
|
2020-03-11 22:24:24 +07:00
|
|
|
return dsa_port_phylink_register(dp);
|
2020-04-14 07:34:39 +07:00
|
|
|
}
|
2020-03-11 22:24:24 +07:00
|
|
|
return 0;
|
|
|
|
|
}
|
2019-05-29 00:38:16 +07:00
|
|
|
|
|
|
|
|
dev_warn(ds->dev,
|
|
|
|
|
"Using legacy PHYLIB callbacks. Please migrate to PHYLINK!\n");
|
|
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
if (of_phy_is_fixed_link(dp->dn))
|
|
|
|
|
return dsa_port_fixed_link_register_of(dp);
|
|
|
|
|
else
|
|
|
|
|
return dsa_port_setup_phy_of(dp, true);
|
|
|
|
|
}
|
2017-10-26 21:50:07 +07:00
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
void dsa_port_link_unregister_of(struct dsa_port *dp)
|
|
|
|
|
{
|
2019-05-29 00:38:16 +07:00
|
|
|
struct dsa_switch *ds = dp->ds;
|
|
|
|
|
|
2020-03-11 22:24:24 +07:00
|
|
|
if (!ds->ops->adjust_link && dp->pl) {
|
2019-05-29 00:38:16 +07:00
|
|
|
rtnl_lock();
|
|
|
|
|
phylink_disconnect_phy(dp->pl);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
phylink_destroy(dp->pl);
|
2020-03-11 22:24:24 +07:00
|
|
|
dp->pl = NULL;
|
2019-05-29 00:38:16 +07:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-23 22:03:46 +07:00
|
|
|
if (of_phy_is_fixed_link(dp->dn))
|
|
|
|
|
of_phy_deregister_fixed_link(dp->dn);
|
|
|
|
|
else
|
|
|
|
|
dsa_port_setup_phy_of(dp, false);
|
2017-10-26 21:50:07 +07:00
|
|
|
}
|
2018-04-26 02:12:52 +07:00
|
|
|
|
|
|
|
|
int dsa_port_get_phy_strings(struct dsa_port *dp, uint8_t *data)
|
|
|
|
|
{
|
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
int ret = -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (of_phy_is_fixed_link(dp->dn))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
phydev = dsa_port_get_phy_device(dp);
|
|
|
|
|
if (IS_ERR_OR_NULL(phydev))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = phy_ethtool_get_strings(phydev, data);
|
|
|
|
|
put_device(&phydev->mdio.dev);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(dsa_port_get_phy_strings);
|
|
|
|
|
|
|
|
|
|
int dsa_port_get_ethtool_phy_stats(struct dsa_port *dp, uint64_t *data)
|
|
|
|
|
{
|
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
int ret = -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (of_phy_is_fixed_link(dp->dn))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
phydev = dsa_port_get_phy_device(dp);
|
|
|
|
|
if (IS_ERR_OR_NULL(phydev))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = phy_ethtool_get_stats(phydev, NULL, data);
|
|
|
|
|
put_device(&phydev->mdio.dev);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(dsa_port_get_ethtool_phy_stats);
|
|
|
|
|
|
|
|
|
|
int dsa_port_get_phy_sset_count(struct dsa_port *dp)
|
|
|
|
|
{
|
|
|
|
|
struct phy_device *phydev;
|
|
|
|
|
int ret = -EOPNOTSUPP;
|
|
|
|
|
|
|
|
|
|
if (of_phy_is_fixed_link(dp->dn))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
phydev = dsa_port_get_phy_device(dp);
|
|
|
|
|
if (IS_ERR_OR_NULL(phydev))
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = phy_ethtool_get_sset_count(phydev);
|
|
|
|
|
put_device(&phydev->mdio.dev);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(dsa_port_get_phy_sset_count);
|