12afee803c
Add a label to the ethtool statistics counters, to differentiate between hardware counters and driver specific ones. Signed-off-by: Ioana Radulescu <ruxandra.radulescu@nxp.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
280 lines
8.4 KiB
C
280 lines
8.4 KiB
C
/* Copyright 2014-2016 Freescale Semiconductor Inc.
|
|
* Copyright 2016 NXP
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* * Neither the name of Freescale Semiconductor nor the
|
|
* names of its contributors may be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
*
|
|
* ALTERNATIVELY, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") as published by the Free Software
|
|
* Foundation, either version 2 of that License or (at your option) any
|
|
* later version.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "dpni.h" /* DPNI_LINK_OPT_* */
|
|
#include "dpaa2-eth.h"
|
|
|
|
/* To be kept in sync with DPNI statistics */
|
|
static char dpaa2_ethtool_stats[][ETH_GSTRING_LEN] = {
|
|
"[hw] rx frames",
|
|
"[hw] rx bytes",
|
|
"[hw] rx mcast frames",
|
|
"[hw] rx mcast bytes",
|
|
"[hw] rx bcast frames",
|
|
"[hw] rx bcast bytes",
|
|
"[hw] tx frames",
|
|
"[hw] tx bytes",
|
|
"[hw] tx mcast frames",
|
|
"[hw] tx mcast bytes",
|
|
"[hw] tx bcast frames",
|
|
"[hw] tx bcast bytes",
|
|
"[hw] rx filtered frames",
|
|
"[hw] rx discarded frames",
|
|
"[hw] rx nobuffer discards",
|
|
"[hw] tx discarded frames",
|
|
"[hw] tx confirmed frames",
|
|
};
|
|
|
|
#define DPAA2_ETH_NUM_STATS ARRAY_SIZE(dpaa2_ethtool_stats)
|
|
|
|
static char dpaa2_ethtool_extras[][ETH_GSTRING_LEN] = {
|
|
/* per-cpu stats */
|
|
"[drv] tx conf frames",
|
|
"[drv] tx conf bytes",
|
|
"[drv] tx sg frames",
|
|
"[drv] tx sg bytes",
|
|
"[drv] rx sg frames",
|
|
"[drv] rx sg bytes",
|
|
"[drv] enqueue portal busy",
|
|
/* Channel stats */
|
|
"[drv] dequeue portal busy",
|
|
"[drv] channel pull errors",
|
|
"[drv] cdan",
|
|
};
|
|
|
|
#define DPAA2_ETH_NUM_EXTRA_STATS ARRAY_SIZE(dpaa2_ethtool_extras)
|
|
|
|
static void dpaa2_eth_get_drvinfo(struct net_device *net_dev,
|
|
struct ethtool_drvinfo *drvinfo)
|
|
{
|
|
strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
|
|
strlcpy(drvinfo->version, dpaa2_eth_drv_version,
|
|
sizeof(drvinfo->version));
|
|
strlcpy(drvinfo->fw_version, "N/A", sizeof(drvinfo->fw_version));
|
|
strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
|
|
sizeof(drvinfo->bus_info));
|
|
}
|
|
|
|
static int
|
|
dpaa2_eth_get_link_ksettings(struct net_device *net_dev,
|
|
struct ethtool_link_ksettings *link_settings)
|
|
{
|
|
struct dpni_link_state state = {0};
|
|
int err = 0;
|
|
struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
|
|
|
|
err = dpni_get_link_state(priv->mc_io, 0, priv->mc_token, &state);
|
|
if (err) {
|
|
netdev_err(net_dev, "ERROR %d getting link state\n", err);
|
|
goto out;
|
|
}
|
|
|
|
/* At the moment, we have no way of interrogating the DPMAC
|
|
* from the DPNI side - and for that matter there may exist
|
|
* no DPMAC at all. So for now we just don't report anything
|
|
* beyond the DPNI attributes.
|
|
*/
|
|
if (state.options & DPNI_LINK_OPT_AUTONEG)
|
|
link_settings->base.autoneg = AUTONEG_ENABLE;
|
|
if (!(state.options & DPNI_LINK_OPT_HALF_DUPLEX))
|
|
link_settings->base.duplex = DUPLEX_FULL;
|
|
link_settings->base.speed = state.rate;
|
|
|
|
out:
|
|
return err;
|
|
}
|
|
|
|
static int
|
|
dpaa2_eth_set_link_ksettings(struct net_device *net_dev,
|
|
const struct ethtool_link_ksettings *link_settings)
|
|
{
|
|
struct dpni_link_cfg cfg = {0};
|
|
struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
|
|
int err = 0;
|
|
|
|
netdev_dbg(net_dev, "Setting link parameters...");
|
|
|
|
/* Due to a temporary MC limitation, the DPNI must be down
|
|
* in order to be able to change link settings. Taking steps to let
|
|
* the user know that.
|
|
*/
|
|
if (netif_running(net_dev)) {
|
|
netdev_info(net_dev, "Sorry, interface must be brought down first.\n");
|
|
return -EACCES;
|
|
}
|
|
|
|
cfg.rate = link_settings->base.speed;
|
|
if (link_settings->base.autoneg == AUTONEG_ENABLE)
|
|
cfg.options |= DPNI_LINK_OPT_AUTONEG;
|
|
else
|
|
cfg.options &= ~DPNI_LINK_OPT_AUTONEG;
|
|
if (link_settings->base.duplex == DUPLEX_HALF)
|
|
cfg.options |= DPNI_LINK_OPT_HALF_DUPLEX;
|
|
else
|
|
cfg.options &= ~DPNI_LINK_OPT_HALF_DUPLEX;
|
|
|
|
err = dpni_set_link_cfg(priv->mc_io, 0, priv->mc_token, &cfg);
|
|
if (err)
|
|
/* ethtool will be loud enough if we return an error; no point
|
|
* in putting our own error message on the console by default
|
|
*/
|
|
netdev_dbg(net_dev, "ERROR %d setting link cfg\n", err);
|
|
|
|
return err;
|
|
}
|
|
|
|
static void dpaa2_eth_get_strings(struct net_device *netdev, u32 stringset,
|
|
u8 *data)
|
|
{
|
|
u8 *p = data;
|
|
int i;
|
|
|
|
switch (stringset) {
|
|
case ETH_SS_STATS:
|
|
for (i = 0; i < DPAA2_ETH_NUM_STATS; i++) {
|
|
strlcpy(p, dpaa2_ethtool_stats[i], ETH_GSTRING_LEN);
|
|
p += ETH_GSTRING_LEN;
|
|
}
|
|
for (i = 0; i < DPAA2_ETH_NUM_EXTRA_STATS; i++) {
|
|
strlcpy(p, dpaa2_ethtool_extras[i], ETH_GSTRING_LEN);
|
|
p += ETH_GSTRING_LEN;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static int dpaa2_eth_get_sset_count(struct net_device *net_dev, int sset)
|
|
{
|
|
switch (sset) {
|
|
case ETH_SS_STATS: /* ethtool_get_stats(), ethtool_get_drvinfo() */
|
|
return DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
}
|
|
|
|
/** Fill in hardware counters, as returned by MC.
|
|
*/
|
|
static void dpaa2_eth_get_ethtool_stats(struct net_device *net_dev,
|
|
struct ethtool_stats *stats,
|
|
u64 *data)
|
|
{
|
|
int i = 0;
|
|
int j, k, err;
|
|
int num_cnt;
|
|
union dpni_statistics dpni_stats;
|
|
u64 cdan = 0;
|
|
u64 portal_busy = 0, pull_err = 0;
|
|
struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
|
|
struct dpaa2_eth_drv_stats *extras;
|
|
struct dpaa2_eth_ch_stats *ch_stats;
|
|
|
|
memset(data, 0,
|
|
sizeof(u64) * (DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS));
|
|
|
|
/* Print standard counters, from DPNI statistics */
|
|
for (j = 0; j <= 2; j++) {
|
|
err = dpni_get_statistics(priv->mc_io, 0, priv->mc_token,
|
|
j, &dpni_stats);
|
|
if (err != 0)
|
|
netdev_warn(net_dev, "dpni_get_stats(%d) failed\n", j);
|
|
switch (j) {
|
|
case 0:
|
|
num_cnt = sizeof(dpni_stats.page_0) / sizeof(u64);
|
|
break;
|
|
case 1:
|
|
num_cnt = sizeof(dpni_stats.page_1) / sizeof(u64);
|
|
break;
|
|
case 2:
|
|
num_cnt = sizeof(dpni_stats.page_2) / sizeof(u64);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
for (k = 0; k < num_cnt; k++)
|
|
*(data + i++) = dpni_stats.raw.counter[k];
|
|
}
|
|
|
|
/* Print per-cpu extra stats */
|
|
for_each_online_cpu(k) {
|
|
extras = per_cpu_ptr(priv->percpu_extras, k);
|
|
for (j = 0; j < sizeof(*extras) / sizeof(__u64); j++)
|
|
*((__u64 *)data + i + j) += *((__u64 *)extras + j);
|
|
}
|
|
i += j;
|
|
|
|
for (j = 0; j < priv->num_channels; j++) {
|
|
ch_stats = &priv->channel[j]->stats;
|
|
cdan += ch_stats->cdan;
|
|
portal_busy += ch_stats->dequeue_portal_busy;
|
|
pull_err += ch_stats->pull_err;
|
|
}
|
|
|
|
*(data + i++) = portal_busy;
|
|
*(data + i++) = pull_err;
|
|
*(data + i++) = cdan;
|
|
}
|
|
|
|
static int dpaa2_eth_get_rxnfc(struct net_device *net_dev,
|
|
struct ethtool_rxnfc *rxnfc, u32 *rule_locs)
|
|
{
|
|
struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
|
|
|
|
switch (rxnfc->cmd) {
|
|
case ETHTOOL_GRXFH:
|
|
/* we purposely ignore cmd->flow_type for now, because the
|
|
* classifier only supports a single set of fields for all
|
|
* protocols
|
|
*/
|
|
rxnfc->data = priv->rx_hash_fields;
|
|
break;
|
|
case ETHTOOL_GRXRINGS:
|
|
rxnfc->data = dpaa2_eth_queue_count(priv);
|
|
break;
|
|
default:
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
const struct ethtool_ops dpaa2_ethtool_ops = {
|
|
.get_drvinfo = dpaa2_eth_get_drvinfo,
|
|
.get_link = ethtool_op_get_link,
|
|
.get_link_ksettings = dpaa2_eth_get_link_ksettings,
|
|
.set_link_ksettings = dpaa2_eth_set_link_ksettings,
|
|
.get_sset_count = dpaa2_eth_get_sset_count,
|
|
.get_ethtool_stats = dpaa2_eth_get_ethtool_stats,
|
|
.get_strings = dpaa2_eth_get_strings,
|
|
.get_rxnfc = dpaa2_eth_get_rxnfc,
|
|
};
|