drivers/net/ethernet/freescale/dpaa/dpaa_ethtool.c

   1 /* Copyright 2008-2016 Freescale Semiconductor, Inc.
   2  *
   3  * Redistribution and use in source and binary forms, with or without
   4  * modification, are permitted provided that the following conditions are met:
   5  *     * Redistributions of source code must retain the above copyright
   6  *       notice, this list of conditions and the following disclaimer.
   7  *     * Redistributions in binary form must reproduce the above copyright
   8  *       notice, this list of conditions and the following disclaimer in the
   9  *       documentation and/or other materials provided with the distribution.
  10  *     * Neither the name of Freescale Semiconductor nor the
  11  *       names of its contributors may be used to endorse or promote products
  12  *       derived from this software without specific prior written permission.
  13  *
  14  *
  15  * ALTERNATIVELY, this software may be distributed under the terms of the
  16  * GNU General Public License ("GPL") as published by the Free Software
  17  * Foundation, either version 2 of that License or (at your option) any
  18  * later version.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY Freescale Semiconductor ``AS IS'' AND ANY
  21  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  22  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  23  * DISCLAIMED. IN NO EVENT SHALL Freescale Semiconductor BE LIABLE FOR ANY
  24  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  27  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  29  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  33
  34 #include <linux/string.h>
  35
  36 #include "dpaa_eth.h"
  37 #include "mac.h"
  38
  39 static const char dpaa_stats_percpu[][ETH_GSTRING_LEN] = {
  40         "interrupts",
  41         "rx packets",
  42         "tx packets",
  43         "tx confirm",
  44         "tx S/G",
  45         "tx error",
  46         "rx error",
  47 };
  48
  49 static char dpaa_stats_global[][ETH_GSTRING_LEN] = {
  50         /* dpa rx errors */
  51         "rx dma error",
  52         "rx frame physical error",
  53         "rx frame size error",
  54         "rx header error",
  55
  56         /* demultiplexing errors */
  57         "qman cg_tdrop",
  58         "qman wred",
  59         "qman error cond",
  60         "qman early window",
  61         "qman late window",
  62         "qman fq tdrop",
  63         "qman fq retired",
  64         "qman orp disabled",
  65
  66         /* congestion related stats */
  67         "congestion time (ms)",
  68         "entered congestion",
  69         "congested (0/1)"
  70 };
  71
  72 #define DPAA_STATS_PERCPU_LEN ARRAY_SIZE(dpaa_stats_percpu)
  73 #define DPAA_STATS_GLOBAL_LEN ARRAY_SIZE(dpaa_stats_global)
  74
  75 static int dpaa_get_link_ksettings(struct net_device *net_dev,
  76                                    struct ethtool_link_ksettings *cmd)
  77 {
  78         if (!net_dev->phydev) {
  79                 netdev_dbg(net_dev, "phy device not initialized\n");
  80                 return 0;
  81         }
  82
  83         phy_ethtool_ksettings_get(net_dev->phydev, cmd);
  84
  85         return 0;
  86 }
  87
  88 static int dpaa_set_link_ksettings(struct net_device *net_dev,
  89                                    const struct ethtool_link_ksettings *cmd)
  90 {
  91         int err;
  92
  93         if (!net_dev->phydev) {
  94                 netdev_err(net_dev, "phy device not initialized\n");
  95                 return -ENODEV;
  96         }
  97
  98         err = phy_ethtool_ksettings_set(net_dev->phydev, cmd);
  99         if (err < 0)
 100                 netdev_err(net_dev, "phy_ethtool_ksettings_set() = %d\n", err);
 101
 102         return err;
 103 }
 104
 105 static void dpaa_get_drvinfo(struct net_device *net_dev,
 106                              struct ethtool_drvinfo *drvinfo)
 107 {
 108         int len;
 109
 110         strlcpy(drvinfo->driver, KBUILD_MODNAME,
 111                 sizeof(drvinfo->driver));
 112         len = snprintf(drvinfo->version, sizeof(drvinfo->version),
 113                        "%X", 0);
 114         len = snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
 115                        "%X", 0);
 116
 117         if (len >= sizeof(drvinfo->fw_version)) {
 118                 /* Truncated output */
 119                 netdev_notice(net_dev, "snprintf() = %d\n", len);
 120         }
 121         strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
 122                 sizeof(drvinfo->bus_info));
 123 }
 124
 125 static u32 dpaa_get_msglevel(struct net_device *net_dev)
 126 {
 127         return ((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable;
 128 }
 129
 130 static void dpaa_set_msglevel(struct net_device *net_dev,
 131                               u32 msg_enable)
 132 {
 133         ((struct dpaa_priv *)netdev_priv(net_dev))->msg_enable = msg_enable;
 134 }
 135
 136 static int dpaa_nway_reset(struct net_device *net_dev)
 137 {
 138         int err;
 139
 140         if (!net_dev->phydev) {
 141                 netdev_err(net_dev, "phy device not initialized\n");
 142                 return -ENODEV;
 143         }
 144
 145         err = 0;
 146         if (net_dev->phydev->autoneg) {
 147                 err = phy_start_aneg(net_dev->phydev);
 148                 if (err < 0)
 149                         netdev_err(net_dev, "phy_start_aneg() = %d\n",
 150                                    err);
 151         }
 152
 153         return err;
 154 }
 155
 156 static void dpaa_get_pauseparam(struct net_device *net_dev,
 157                                 struct ethtool_pauseparam *epause)
 158 {
 159         struct mac_device *mac_dev;
 160         struct dpaa_priv *priv;
 161
 162         priv = netdev_priv(net_dev);
 163         mac_dev = priv->mac_dev;
 164
 165         if (!net_dev->phydev) {
 166                 netdev_err(net_dev, "phy device not initialized\n");
 167                 return;
 168         }
 169
 170         epause->autoneg = mac_dev->autoneg_pause;
 171         epause->rx_pause = mac_dev->rx_pause_active;
 172         epause->tx_pause = mac_dev->tx_pause_active;
 173 }
 174
 175 static int dpaa_set_pauseparam(struct net_device *net_dev,
 176                                struct ethtool_pauseparam *epause)
 177 {
 178         struct mac_device *mac_dev;
 179         struct phy_device *phydev;
 180         bool rx_pause, tx_pause;
 181         struct dpaa_priv *priv;
 182         u32 newadv, oldadv;
 183         int err;
 184
 185         priv = netdev_priv(net_dev);
 186         mac_dev = priv->mac_dev;
 187
 188         phydev = net_dev->phydev;
 189         if (!phydev) {
 190                 netdev_err(net_dev, "phy device not initialized\n");
 191                 return -ENODEV;
 192         }
 193
 194         if (!(phydev->supported & SUPPORTED_Pause) ||
 195             (!(phydev->supported & SUPPORTED_Asym_Pause) &&
 196             (epause->rx_pause != epause->tx_pause)))
 197                 return -EINVAL;
 198
 199         /* The MAC should know how to handle PAUSE frame autonegotiation before
 200          * adjust_link is triggered by a forced renegotiation of sym/asym PAUSE
 201          * settings.
 202          */
 203         mac_dev->autoneg_pause = !!epause->autoneg;
 204         mac_dev->rx_pause_req = !!epause->rx_pause;
 205         mac_dev->tx_pause_req = !!epause->tx_pause;
 206
 207         /* Determine the sym/asym advertised PAUSE capabilities from the desired
 208          * rx/tx pause settings.
 209          */
 210         newadv = 0;
 211         if (epause->rx_pause)
 212                 newadv = ADVERTISED_Pause | ADVERTISED_Asym_Pause;
 213         if (epause->tx_pause)
 214                 newadv |= ADVERTISED_Asym_Pause;
 215
 216         oldadv = phydev->advertising &
 217                         (ADVERTISED_Pause | ADVERTISED_Asym_Pause);
 218
 219         /* If there are differences between the old and the new advertised
 220          * values, restart PHY autonegotiation and advertise the new values.
 221          */
 222         if (oldadv != newadv) {
 223                 phydev->advertising &= ~(ADVERTISED_Pause
 224                                 | ADVERTISED_Asym_Pause);
 225                 phydev->advertising |= newadv;
 226                 if (phydev->autoneg) {
 227                         err = phy_start_aneg(phydev);
 228                         if (err < 0)
 229                                 netdev_err(net_dev, "phy_start_aneg() = %d\n",
 230                                            err);
 231                 }
 232         }
 233
 234         fman_get_pause_cfg(mac_dev, &rx_pause, &tx_pause);
 235         err = fman_set_mac_active_pause(mac_dev, rx_pause, tx_pause);
 236         if (err < 0)
 237                 netdev_err(net_dev, "set_mac_active_pause() = %d\n", err);
 238
 239         return err;
 240 }
 241
 242 static int dpaa_get_sset_count(struct net_device *net_dev, int type)
 243 {
 244         unsigned int total_stats, num_stats;
 245
 246         num_stats   = num_online_cpus() + 1;
 247         total_stats = num_stats * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM) +
 248                         DPAA_STATS_GLOBAL_LEN;
 249
 250         switch (type) {
 251         case ETH_SS_STATS:
 252                 return total_stats;
 253         default:
 254                 return -EOPNOTSUPP;
 255         }
 256 }
 257
 258 static void copy_stats(struct dpaa_percpu_priv *percpu_priv, int num_cpus,
 259                        int crr_cpu, u64 *bp_count, u64 *data)
 260 {
 261         int num_values = num_cpus + 1;
 262         int crr = 0, j;
 263
 264         /* update current CPU's stats and also add them to the total values */
 265         data[crr * num_values + crr_cpu] = percpu_priv->in_interrupt;
 266         data[crr++ * num_values + num_cpus] += percpu_priv->in_interrupt;
 267
 268         data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_packets;
 269         data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_packets;
 270
 271         data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_packets;
 272         data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_packets;
 273
 274         data[crr * num_values + crr_cpu] = percpu_priv->tx_confirm;
 275         data[crr++ * num_values + num_cpus] += percpu_priv->tx_confirm;
 276
 277         data[crr * num_values + crr_cpu] = percpu_priv->tx_frag_skbuffs;
 278         data[crr++ * num_values + num_cpus] += percpu_priv->tx_frag_skbuffs;
 279
 280         data[crr * num_values + crr_cpu] = percpu_priv->stats.tx_errors;
 281         data[crr++ * num_values + num_cpus] += percpu_priv->stats.tx_errors;
 282
 283         data[crr * num_values + crr_cpu] = percpu_priv->stats.rx_errors;
 284         data[crr++ * num_values + num_cpus] += percpu_priv->stats.rx_errors;
 285
 286         for (j = 0; j < DPAA_BPS_NUM; j++) {
 287                 data[crr * num_values + crr_cpu] = bp_count[j];
 288                 data[crr++ * num_values + num_cpus] += bp_count[j];
 289         }
 290 }
 291
 292 static void dpaa_get_ethtool_stats(struct net_device *net_dev,
 293                                    struct ethtool_stats *stats, u64 *data)
 294 {
 295         u64 bp_count[DPAA_BPS_NUM], cg_time, cg_num;
 296         struct dpaa_percpu_priv *percpu_priv;
 297         struct dpaa_rx_errors rx_errors;
 298         unsigned int num_cpus, offset;
 299         struct dpaa_ern_cnt ern_cnt;
 300         struct dpaa_bp *dpaa_bp;
 301         struct dpaa_priv *priv;
 302         int total_stats, i, j;
 303         bool cg_status;
 304
 305         total_stats = dpaa_get_sset_count(net_dev, ETH_SS_STATS);
 306         priv     = netdev_priv(net_dev);
 307         num_cpus = num_online_cpus();
 308
 309         memset(&bp_count, 0, sizeof(bp_count));
 310         memset(&rx_errors, 0, sizeof(struct dpaa_rx_errors));
 311         memset(&ern_cnt, 0, sizeof(struct dpaa_ern_cnt));
 312         memset(data, 0, total_stats * sizeof(u64));
 313
 314         for_each_online_cpu(i) {
 315                 percpu_priv = per_cpu_ptr(priv->percpu_priv, i);
 316                 for (j = 0; j < DPAA_BPS_NUM; j++) {
 317                         dpaa_bp = priv->dpaa_bps[j];
 318                         if (!dpaa_bp->percpu_count)
 319                                 continue;
 320                         bp_count[j] = *(per_cpu_ptr(dpaa_bp->percpu_count, i));
 321                 }
 322                 rx_errors.dme += percpu_priv->rx_errors.dme;
 323                 rx_errors.fpe += percpu_priv->rx_errors.fpe;
 324                 rx_errors.fse += percpu_priv->rx_errors.fse;
 325                 rx_errors.phe += percpu_priv->rx_errors.phe;
 326
 327                 ern_cnt.cg_tdrop     += percpu_priv->ern_cnt.cg_tdrop;
 328                 ern_cnt.wred         += percpu_priv->ern_cnt.wred;
 329                 ern_cnt.err_cond     += percpu_priv->ern_cnt.err_cond;
 330                 ern_cnt.early_window += percpu_priv->ern_cnt.early_window;
 331                 ern_cnt.late_window  += percpu_priv->ern_cnt.late_window;
 332                 ern_cnt.fq_tdrop     += percpu_priv->ern_cnt.fq_tdrop;
 333                 ern_cnt.fq_retired   += percpu_priv->ern_cnt.fq_retired;
 334                 ern_cnt.orp_zero     += percpu_priv->ern_cnt.orp_zero;
 335
 336                 copy_stats(percpu_priv, num_cpus, i, bp_count, data);
 337         }
 338
 339         offset = (num_cpus + 1) * (DPAA_STATS_PERCPU_LEN + DPAA_BPS_NUM);
 340         memcpy(data + offset, &rx_errors, sizeof(struct dpaa_rx_errors));
 341
 342         offset += sizeof(struct dpaa_rx_errors) / sizeof(u64);
 343         memcpy(data + offset, &ern_cnt, sizeof(struct dpaa_ern_cnt));
 344
 345         /* gather congestion related counters */
 346         cg_num    = 0;
 347         cg_status = 0;
 348         cg_time   = jiffies_to_msecs(priv->cgr_data.congested_jiffies);
 349         if (qman_query_cgr_congested(&priv->cgr_data.cgr, &cg_status) == 0) {
 350                 cg_num    = priv->cgr_data.cgr_congested_count;
 351
 352                 /* reset congestion stats (like QMan API does */
 353                 priv->cgr_data.congested_jiffies   = 0;
 354                 priv->cgr_data.cgr_congested_count = 0;
 355         }
 356
 357         offset += sizeof(struct dpaa_ern_cnt) / sizeof(u64);
 358         data[offset++] = cg_time;
 359         data[offset++] = cg_num;
 360         data[offset++] = cg_status;
 361 }
 362
 363 static void dpaa_get_strings(struct net_device *net_dev, u32 stringset,
 364                              u8 *data)
 365 {
 366         unsigned int i, j, num_cpus, size;
 367         char string_cpu[ETH_GSTRING_LEN];
 368         u8 *strings;
 369
 370         memset(string_cpu, 0, sizeof(string_cpu));
 371         strings   = data;
 372         num_cpus  = num_online_cpus();
 373         size      = DPAA_STATS_GLOBAL_LEN * ETH_GSTRING_LEN;
 374
 375         for (i = 0; i < DPAA_STATS_PERCPU_LEN; i++) {
 376                 for (j = 0; j < num_cpus; j++) {
 377                         snprintf(string_cpu, ETH_GSTRING_LEN, "%s [CPU %d]",
 378                                  dpaa_stats_percpu[i], j);
 379                         memcpy(strings, string_cpu, ETH_GSTRING_LEN);
 380                         strings += ETH_GSTRING_LEN;
 381                 }
 382                 snprintf(string_cpu, ETH_GSTRING_LEN, "%s [TOTAL]",
 383                          dpaa_stats_percpu[i]);
 384                 memcpy(strings, string_cpu, ETH_GSTRING_LEN);
 385                 strings += ETH_GSTRING_LEN;
 386         }
 387         for (i = 0; i < DPAA_BPS_NUM; i++) {
 388                 for (j = 0; j < num_cpus; j++) {
 389                         snprintf(string_cpu, ETH_GSTRING_LEN,
 390                                  "bpool %c [CPU %d]", 'a' + i, j);
 391                         memcpy(strings, string_cpu, ETH_GSTRING_LEN);
 392                         strings += ETH_GSTRING_LEN;
 393                 }
 394                 snprintf(string_cpu, ETH_GSTRING_LEN, "bpool %c [TOTAL]",
 395                          'a' + i);
 396                 memcpy(strings, string_cpu, ETH_GSTRING_LEN);
 397                 strings += ETH_GSTRING_LEN;
 398         }
 399         memcpy(strings, dpaa_stats_global, size);
 400 }
 401
 402 static int dpaa_get_hash_opts(struct net_device *dev,
 403                               struct ethtool_rxnfc *cmd)
 404 {
 405         struct dpaa_priv *priv = netdev_priv(dev);
 406
 407         cmd->data = 0;
 408
 409         switch (cmd->flow_type) {
 410         case TCP_V4_FLOW:
 411         case TCP_V6_FLOW:
 412         case UDP_V4_FLOW:
 413         case UDP_V6_FLOW:
 414                 if (priv->keygen_in_use)
 415                         cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
 416                 /* Fall through */
 417         case IPV4_FLOW:
 418         case IPV6_FLOW:
 419         case SCTP_V4_FLOW:
 420         case SCTP_V6_FLOW:
 421         case AH_ESP_V4_FLOW:
 422         case AH_ESP_V6_FLOW:
 423         case AH_V4_FLOW:
 424         case AH_V6_FLOW:
 425         case ESP_V4_FLOW:
 426         case ESP_V6_FLOW:
 427                 if (priv->keygen_in_use)
 428                         cmd->data |= RXH_IP_SRC | RXH_IP_DST;
 429                 break;
 430         default:
 431                 cmd->data = 0;
 432                 break;
 433         }
 434
 435         return 0;
 436 }
 437
 438 static int dpaa_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
 439                           u32 *unused)
 440 {
 441         int ret = -EOPNOTSUPP;
 442
 443         switch (cmd->cmd) {
 444         case ETHTOOL_GRXFH:
 445                 ret = dpaa_get_hash_opts(dev, cmd);
 446                 break;
 447         default:
 448                 break;
 449         }
 450
 451         return ret;
 452 }
 453
 454 static void dpaa_set_hash(struct net_device *net_dev, bool enable)
 455 {
 456         struct mac_device *mac_dev;
 457         struct fman_port *rxport;
 458         struct dpaa_priv *priv;
 459
 460         priv = netdev_priv(net_dev);
 461         mac_dev = priv->mac_dev;
 462         rxport = mac_dev->port[0];
 463
 464         fman_port_use_kg_hash(rxport, enable);
 465         priv->keygen_in_use = enable;
 466 }
 467
 468 static int dpaa_set_hash_opts(struct net_device *dev,
 469                               struct ethtool_rxnfc *nfc)
 470 {
 471         int ret = -EINVAL;
 472
 473         /* we support hashing on IPv4/v6 src/dest IP and L4 src/dest port */
 474         if (nfc->data &
 475             ~(RXH_IP_SRC | RXH_IP_DST | RXH_L4_B_0_1 | RXH_L4_B_2_3))
 476                 return -EINVAL;
 477
 478         switch (nfc->flow_type) {
 479         case TCP_V4_FLOW:
 480         case TCP_V6_FLOW:
 481         case UDP_V4_FLOW:
 482         case UDP_V6_FLOW:
 483         case IPV4_FLOW:
 484         case IPV6_FLOW:
 485         case SCTP_V4_FLOW:
 486         case SCTP_V6_FLOW:
 487         case AH_ESP_V4_FLOW:
 488         case AH_ESP_V6_FLOW:
 489         case AH_V4_FLOW:
 490         case AH_V6_FLOW:
 491         case ESP_V4_FLOW:
 492         case ESP_V6_FLOW:
 493                 dpaa_set_hash(dev, !!nfc->data);
 494                 ret = 0;
 495                 break;
 496         default:
 497                 break;
 498         }
 499
 500         return ret;
 501 }
 502
 503 static int dpaa_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
 504 {
 505         int ret = -EOPNOTSUPP;
 506
 507         switch (cmd->cmd) {
 508         case ETHTOOL_SRXFH:
 509                 ret = dpaa_set_hash_opts(dev, cmd);
 510                 break;
 511         default:
 512                 break;
 513         }
 514
 515         return ret;
 516 }
 517
 518 const struct ethtool_ops dpaa_ethtool_ops = {
 519         .get_drvinfo = dpaa_get_drvinfo,
 520         .get_msglevel = dpaa_get_msglevel,
 521         .set_msglevel = dpaa_set_msglevel,
 522         .nway_reset = dpaa_nway_reset,
 523         .get_pauseparam = dpaa_get_pauseparam,
 524         .set_pauseparam = dpaa_set_pauseparam,
 525         .get_link = ethtool_op_get_link,
 526         .get_sset_count = dpaa_get_sset_count,
 527         .get_ethtool_stats = dpaa_get_ethtool_stats,
 528         .get_strings = dpaa_get_strings,
 529         .get_link_ksettings = dpaa_get_link_ksettings,
 530         .set_link_ksettings = dpaa_set_link_ksettings,
 531         .get_rxnfc = dpaa_get_rxnfc,
 532         .set_rxnfc = dpaa_set_rxnfc,
 533 };