/* 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; } 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, };