drivers/net/ethernet/freescale/dpaa2/dpaa2-ethtool.c

   1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause)
   2 /* Copyright 2014-2016 Freescale Semiconductor Inc.
   3  * Copyright 2016 NXP
   4  */
   5
   6 #include <linux/net_tstamp.h>
   7
   8 #include "dpni.h"       /* DPNI_LINK_OPT_* */
   9 #include "dpaa2-eth.h"
  10
  11 /* To be kept in sync with DPNI statistics */
  12 static char dpaa2_ethtool_stats[][ETH_GSTRING_LEN] = {
  13         "[hw] rx frames",
  14         "[hw] rx bytes",
  15         "[hw] rx mcast frames",
  16         "[hw] rx mcast bytes",
  17         "[hw] rx bcast frames",
  18         "[hw] rx bcast bytes",
  19         "[hw] tx frames",
  20         "[hw] tx bytes",
  21         "[hw] tx mcast frames",
  22         "[hw] tx mcast bytes",
  23         "[hw] tx bcast frames",
  24         "[hw] tx bcast bytes",
  25         "[hw] rx filtered frames",
  26         "[hw] rx discarded frames",
  27         "[hw] rx nobuffer discards",
  28         "[hw] tx discarded frames",
  29         "[hw] tx confirmed frames",
  30 };
  31
  32 #define DPAA2_ETH_NUM_STATS     ARRAY_SIZE(dpaa2_ethtool_stats)
  33
  34 static char dpaa2_ethtool_extras[][ETH_GSTRING_LEN] = {
  35         /* per-cpu stats */
  36         "[drv] tx conf frames",
  37         "[drv] tx conf bytes",
  38         "[drv] tx sg frames",
  39         "[drv] tx sg bytes",
  40         "[drv] tx realloc frames",
  41         "[drv] rx sg frames",
  42         "[drv] rx sg bytes",
  43         "[drv] enqueue portal busy",
  44         /* Channel stats */
  45         "[drv] dequeue portal busy",
  46         "[drv] channel pull errors",
  47         "[drv] cdan",
  48 };
  49
  50 #define DPAA2_ETH_NUM_EXTRA_STATS       ARRAY_SIZE(dpaa2_ethtool_extras)
  51
  52 static void dpaa2_eth_get_drvinfo(struct net_device *net_dev,
  53                                   struct ethtool_drvinfo *drvinfo)
  54 {
  55         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
  56
  57         strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
  58
  59         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  60                  "%u.%u", priv->dpni_ver_major, priv->dpni_ver_minor);
  61
  62         strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
  63                 sizeof(drvinfo->bus_info));
  64 }
  65
  66 static int
  67 dpaa2_eth_get_link_ksettings(struct net_device *net_dev,
  68                              struct ethtool_link_ksettings *link_settings)
  69 {
  70         struct dpni_link_state state = {0};
  71         int err = 0;
  72         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
  73
  74         err = dpni_get_link_state(priv->mc_io, 0, priv->mc_token, &state);
  75         if (err) {
  76                 netdev_err(net_dev, "ERROR %d getting link state\n", err);
  77                 goto out;
  78         }
  79
  80         /* At the moment, we have no way of interrogating the DPMAC
  81          * from the DPNI side - and for that matter there may exist
  82          * no DPMAC at all. So for now we just don't report anything
  83          * beyond the DPNI attributes.
  84          */
  85         if (state.options & DPNI_LINK_OPT_AUTONEG)
  86                 link_settings->base.autoneg = AUTONEG_ENABLE;
  87         if (!(state.options & DPNI_LINK_OPT_HALF_DUPLEX))
  88                 link_settings->base.duplex = DUPLEX_FULL;
  89         link_settings->base.speed = state.rate;
  90
  91 out:
  92         return err;
  93 }
  94
  95 #define DPNI_DYNAMIC_LINK_SET_VER_MAJOR         7
  96 #define DPNI_DYNAMIC_LINK_SET_VER_MINOR         1
  97 static int
  98 dpaa2_eth_set_link_ksettings(struct net_device *net_dev,
  99                              const struct ethtool_link_ksettings *link_settings)
 100 {
 101         struct dpni_link_cfg cfg = {0};
 102         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 103         int err = 0;
 104
 105         /* If using an older MC version, the DPNI must be down
 106          * in order to be able to change link settings. Taking steps to let
 107          * the user know that.
 108          */
 109         if (dpaa2_eth_cmp_dpni_ver(priv, DPNI_DYNAMIC_LINK_SET_VER_MAJOR,
 110                                    DPNI_DYNAMIC_LINK_SET_VER_MINOR) < 0) {
 111                 if (netif_running(net_dev)) {
 112                         netdev_info(net_dev, "Interface must be brought down first.\n");
 113                         return -EACCES;
 114                 }
 115         }
 116
 117         cfg.rate = link_settings->base.speed;
 118         if (link_settings->base.autoneg == AUTONEG_ENABLE)
 119                 cfg.options |= DPNI_LINK_OPT_AUTONEG;
 120         else
 121                 cfg.options &= ~DPNI_LINK_OPT_AUTONEG;
 122         if (link_settings->base.duplex  == DUPLEX_HALF)
 123                 cfg.options |= DPNI_LINK_OPT_HALF_DUPLEX;
 124         else
 125                 cfg.options &= ~DPNI_LINK_OPT_HALF_DUPLEX;
 126
 127         err = dpni_set_link_cfg(priv->mc_io, 0, priv->mc_token, &cfg);
 128         if (err)
 129                 /* ethtool will be loud enough if we return an error; no point
 130                  * in putting our own error message on the console by default
 131                  */
 132                 netdev_dbg(net_dev, "ERROR %d setting link cfg\n", err);
 133
 134         return err;
 135 }
 136
 137 static void dpaa2_eth_get_strings(struct net_device *netdev, u32 stringset,
 138                                   u8 *data)
 139 {
 140         u8 *p = data;
 141         int i;
 142
 143         switch (stringset) {
 144         case ETH_SS_STATS:
 145                 for (i = 0; i < DPAA2_ETH_NUM_STATS; i++) {
 146                         strlcpy(p, dpaa2_ethtool_stats[i], ETH_GSTRING_LEN);
 147                         p += ETH_GSTRING_LEN;
 148                 }
 149                 for (i = 0; i < DPAA2_ETH_NUM_EXTRA_STATS; i++) {
 150                         strlcpy(p, dpaa2_ethtool_extras[i], ETH_GSTRING_LEN);
 151                         p += ETH_GSTRING_LEN;
 152                 }
 153                 break;
 154         }
 155 }
 156
 157 static int dpaa2_eth_get_sset_count(struct net_device *net_dev, int sset)
 158 {
 159         switch (sset) {
 160         case ETH_SS_STATS: /* ethtool_get_stats(), ethtool_get_drvinfo() */
 161                 return DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS;
 162         default:
 163                 return -EOPNOTSUPP;
 164         }
 165 }
 166
 167 /** Fill in hardware counters, as returned by MC.
 168  */
 169 static void dpaa2_eth_get_ethtool_stats(struct net_device *net_dev,
 170                                         struct ethtool_stats *stats,
 171                                         u64 *data)
 172 {
 173         int i = 0;
 174         int j, k, err;
 175         int num_cnt;
 176         union dpni_statistics dpni_stats;
 177         u64 cdan = 0;
 178         u64 portal_busy = 0, pull_err = 0;
 179         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 180         struct dpaa2_eth_drv_stats *extras;
 181         struct dpaa2_eth_ch_stats *ch_stats;
 182
 183         memset(data, 0,
 184                sizeof(u64) * (DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS));
 185
 186         /* Print standard counters, from DPNI statistics */
 187         for (j = 0; j <= 2; j++) {
 188                 err = dpni_get_statistics(priv->mc_io, 0, priv->mc_token,
 189                                           j, &dpni_stats);
 190                 if (err != 0)
 191                         netdev_warn(net_dev, "dpni_get_stats(%d) failed\n", j);
 192                 switch (j) {
 193                 case 0:
 194                         num_cnt = sizeof(dpni_stats.page_0) / sizeof(u64);
 195                         break;
 196                 case 1:
 197                         num_cnt = sizeof(dpni_stats.page_1) / sizeof(u64);
 198                         break;
 199                 case 2:
 200                         num_cnt = sizeof(dpni_stats.page_2) / sizeof(u64);
 201                         break;
 202                 }
 203                 for (k = 0; k < num_cnt; k++)
 204                         *(data + i++) = dpni_stats.raw.counter[k];
 205         }
 206
 207         /* Print per-cpu extra stats */
 208         for_each_online_cpu(k) {
 209                 extras = per_cpu_ptr(priv->percpu_extras, k);
 210                 for (j = 0; j < sizeof(*extras) / sizeof(__u64); j++)
 211                         *((__u64 *)data + i + j) += *((__u64 *)extras + j);
 212         }
 213         i += j;
 214
 215         for (j = 0; j < priv->num_channels; j++) {
 216                 ch_stats = &priv->channel[j]->stats;
 217                 cdan += ch_stats->cdan;
 218                 portal_busy += ch_stats->dequeue_portal_busy;
 219                 pull_err += ch_stats->pull_err;
 220         }
 221
 222         *(data + i++) = portal_busy;
 223         *(data + i++) = pull_err;
 224         *(data + i++) = cdan;
 225 }
 226
 227 static int prep_eth_rule(struct ethhdr *eth_value, struct ethhdr *eth_mask,
 228                          void *key, void *mask)
 229 {
 230         int off;
 231
 232         if (eth_mask->h_proto) {
 233                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE);
 234                 *(__be16 *)(key + off) = eth_value->h_proto;
 235                 *(__be16 *)(mask + off) = eth_mask->h_proto;
 236         }
 237
 238         if (!is_zero_ether_addr(eth_mask->h_source)) {
 239                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_SA);
 240                 ether_addr_copy(key + off, eth_value->h_source);
 241                 ether_addr_copy(mask + off, eth_mask->h_source);
 242         }
 243
 244         if (!is_zero_ether_addr(eth_mask->h_dest)) {
 245                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_DA);
 246                 ether_addr_copy(key + off, eth_value->h_dest);
 247                 ether_addr_copy(mask + off, eth_mask->h_dest);
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int prep_uip_rule(struct ethtool_usrip4_spec *uip_value,
 254                          struct ethtool_usrip4_spec *uip_mask,
 255                          void *key, void *mask)
 256 {
 257         int off;
 258         u32 tmp_value, tmp_mask;
 259
 260         if (uip_mask->tos || uip_mask->ip_ver)
 261                 return -EOPNOTSUPP;
 262
 263         if (uip_mask->ip4src) {
 264                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_SRC);
 265                 *(__be32 *)(key + off) = uip_value->ip4src;
 266                 *(__be32 *)(mask + off) = uip_mask->ip4src;
 267         }
 268
 269         if (uip_mask->ip4dst) {
 270                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_DST);
 271                 *(__be32 *)(key + off) = uip_value->ip4dst;
 272                 *(__be32 *)(mask + off) = uip_mask->ip4dst;
 273         }
 274
 275         if (uip_mask->proto) {
 276                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_PROTO);
 277                 *(u8 *)(key + off) = uip_value->proto;
 278                 *(u8 *)(mask + off) = uip_mask->proto;
 279         }
 280
 281         if (uip_mask->l4_4_bytes) {
 282                 tmp_value = be32_to_cpu(uip_value->l4_4_bytes);
 283                 tmp_mask = be32_to_cpu(uip_mask->l4_4_bytes);
 284
 285                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
 286                 *(__be16 *)(key + off) = htons(tmp_value >> 16);
 287                 *(__be16 *)(mask + off) = htons(tmp_mask >> 16);
 288
 289                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
 290                 *(__be16 *)(key + off) = htons(tmp_value & 0xFFFF);
 291                 *(__be16 *)(mask + off) = htons(tmp_mask & 0xFFFF);
 292         }
 293
 294         /* Only apply the rule for IPv4 frames */
 295         off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE);
 296         *(__be16 *)(key + off) = htons(ETH_P_IP);
 297         *(__be16 *)(mask + off) = htons(0xFFFF);
 298
 299         return 0;
 300 }
 301
 302 static int prep_l4_rule(struct ethtool_tcpip4_spec *l4_value,
 303                         struct ethtool_tcpip4_spec *l4_mask,
 304                         void *key, void *mask, u8 l4_proto)
 305 {
 306         int off;
 307
 308         if (l4_mask->tos)
 309                 return -EOPNOTSUPP;
 310
 311         if (l4_mask->ip4src) {
 312                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_SRC);
 313                 *(__be32 *)(key + off) = l4_value->ip4src;
 314                 *(__be32 *)(mask + off) = l4_mask->ip4src;
 315         }
 316
 317         if (l4_mask->ip4dst) {
 318                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_DST);
 319                 *(__be32 *)(key + off) = l4_value->ip4dst;
 320                 *(__be32 *)(mask + off) = l4_mask->ip4dst;
 321         }
 322
 323         if (l4_mask->psrc) {
 324                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
 325                 *(__be16 *)(key + off) = l4_value->psrc;
 326                 *(__be16 *)(mask + off) = l4_mask->psrc;
 327         }
 328
 329         if (l4_mask->pdst) {
 330                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
 331                 *(__be16 *)(key + off) = l4_value->pdst;
 332                 *(__be16 *)(mask + off) = l4_mask->pdst;
 333         }
 334
 335         /* Only apply the rule for IPv4 frames with the specified L4 proto */
 336         off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE);
 337         *(__be16 *)(key + off) = htons(ETH_P_IP);
 338         *(__be16 *)(mask + off) = htons(0xFFFF);
 339
 340         off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_PROTO);
 341         *(u8 *)(key + off) = l4_proto;
 342         *(u8 *)(mask + off) = 0xFF;
 343
 344         return 0;
 345 }
 346
 347 static int prep_ext_rule(struct ethtool_flow_ext *ext_value,
 348                          struct ethtool_flow_ext *ext_mask,
 349                          void *key, void *mask)
 350 {
 351         int off;
 352
 353         if (ext_mask->vlan_etype)
 354                 return -EOPNOTSUPP;
 355
 356         if (ext_mask->vlan_tci) {
 357                 off = dpaa2_eth_cls_fld_off(NET_PROT_VLAN, NH_FLD_VLAN_TCI);
 358                 *(__be16 *)(key + off) = ext_value->vlan_tci;
 359                 *(__be16 *)(mask + off) = ext_mask->vlan_tci;
 360         }
 361
 362         return 0;
 363 }
 364
 365 static int prep_mac_ext_rule(struct ethtool_flow_ext *ext_value,
 366                              struct ethtool_flow_ext *ext_mask,
 367                              void *key, void *mask)
 368 {
 369         int off;
 370
 371         if (!is_zero_ether_addr(ext_mask->h_dest)) {
 372                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_DA);
 373                 ether_addr_copy(key + off, ext_value->h_dest);
 374                 ether_addr_copy(mask + off, ext_mask->h_dest);
 375         }
 376
 377         return 0;
 378 }
 379
 380 static int prep_cls_rule(struct ethtool_rx_flow_spec *fs, void *key, void *mask)
 381 {
 382         int err;
 383
 384         switch (fs->flow_type & 0xFF) {
 385         case ETHER_FLOW:
 386                 err = prep_eth_rule(&fs->h_u.ether_spec, &fs->m_u.ether_spec,
 387                                     key, mask);
 388                 break;
 389         case IP_USER_FLOW:
 390                 err = prep_uip_rule(&fs->h_u.usr_ip4_spec,
 391                                     &fs->m_u.usr_ip4_spec, key, mask);
 392                 break;
 393         case TCP_V4_FLOW:
 394                 err = prep_l4_rule(&fs->h_u.tcp_ip4_spec, &fs->m_u.tcp_ip4_spec,
 395                                    key, mask, IPPROTO_TCP);
 396                 break;
 397         case UDP_V4_FLOW:
 398                 err = prep_l4_rule(&fs->h_u.udp_ip4_spec, &fs->m_u.udp_ip4_spec,
 399                                    key, mask, IPPROTO_UDP);
 400                 break;
 401         case SCTP_V4_FLOW:
 402                 err = prep_l4_rule(&fs->h_u.sctp_ip4_spec,
 403                                    &fs->m_u.sctp_ip4_spec, key, mask,
 404                                    IPPROTO_SCTP);
 405                 break;
 406         default:
 407                 return -EOPNOTSUPP;
 408         }
 409
 410         if (err)
 411                 return err;
 412
 413         if (fs->flow_type & FLOW_EXT) {
 414                 err = prep_ext_rule(&fs->h_ext, &fs->m_ext, key, mask);
 415                 if (err)
 416                         return err;
 417         }
 418
 419         if (fs->flow_type & FLOW_MAC_EXT) {
 420                 err = prep_mac_ext_rule(&fs->h_ext, &fs->m_ext, key, mask);
 421                 if (err)
 422                         return err;
 423         }
 424
 425         return 0;
 426 }
 427
 428 static int do_cls_rule(struct net_device *net_dev,
 429                        struct ethtool_rx_flow_spec *fs,
 430                        bool add)
 431 {
 432         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 433         struct device *dev = net_dev->dev.parent;
 434         struct dpni_rule_cfg rule_cfg = { 0 };
 435         struct dpni_fs_action_cfg fs_act = { 0 };
 436         dma_addr_t key_iova;
 437         void *key_buf;
 438         int err;
 439
 440         if (fs->ring_cookie != RX_CLS_FLOW_DISC &&
 441             fs->ring_cookie >= dpaa2_eth_queue_count(priv))
 442                 return -EINVAL;
 443
 444         rule_cfg.key_size = dpaa2_eth_cls_key_size();
 445
 446         /* allocate twice the key size, for the actual key and for mask */
 447         key_buf = kzalloc(rule_cfg.key_size * 2, GFP_KERNEL);
 448         if (!key_buf)
 449                 return -ENOMEM;
 450
 451         /* Fill the key and mask memory areas */
 452         err = prep_cls_rule(fs, key_buf, key_buf + rule_cfg.key_size);
 453         if (err)
 454                 goto free_mem;
 455
 456         key_iova = dma_map_single(dev, key_buf, rule_cfg.key_size * 2,
 457                                   DMA_TO_DEVICE);
 458         if (dma_mapping_error(dev, key_iova)) {
 459                 err = -ENOMEM;
 460                 goto free_mem;
 461         }
 462
 463         rule_cfg.key_iova = key_iova;
 464         rule_cfg.mask_iova = key_iova + rule_cfg.key_size;
 465
 466         if (add) {
 467                 if (fs->ring_cookie == RX_CLS_FLOW_DISC)
 468                         fs_act.options |= DPNI_FS_OPT_DISCARD;
 469                 else
 470                         fs_act.flow_id = fs->ring_cookie;
 471                 err = dpni_add_fs_entry(priv->mc_io, 0, priv->mc_token, 0,
 472                                         fs->location, &rule_cfg, &fs_act);
 473         } else {
 474                 err = dpni_remove_fs_entry(priv->mc_io, 0, priv->mc_token, 0,
 475                                            &rule_cfg);
 476         }
 477
 478         dma_unmap_single(dev, key_iova, rule_cfg.key_size * 2, DMA_TO_DEVICE);
 479
 480 free_mem:
 481         kfree(key_buf);
 482
 483         return err;
 484 }
 485
 486 static int update_cls_rule(struct net_device *net_dev,
 487                            struct ethtool_rx_flow_spec *new_fs,
 488                            int location)
 489 {
 490         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 491         struct dpaa2_eth_cls_rule *rule;
 492         int err = -EINVAL;
 493
 494         if (!priv->rx_cls_enabled)
 495                 return -EOPNOTSUPP;
 496
 497         if (location >= dpaa2_eth_fs_count(priv))
 498                 return -EINVAL;
 499
 500         rule = &priv->cls_rules[location];
 501
 502         /* If a rule is present at the specified location, delete it. */
 503         if (rule->in_use) {
 504                 err = do_cls_rule(net_dev, &rule->fs, false);
 505                 if (err)
 506                         return err;
 507
 508                 rule->in_use = 0;
 509         }
 510
 511         /* If no new entry to add, return here */
 512         if (!new_fs)
 513                 return err;
 514
 515         err = do_cls_rule(net_dev, new_fs, true);
 516         if (err)
 517                 return err;
 518
 519         rule->in_use = 1;
 520         rule->fs = *new_fs;
 521
 522         return 0;
 523 }
 524
 525 static int dpaa2_eth_get_rxnfc(struct net_device *net_dev,
 526                                struct ethtool_rxnfc *rxnfc, u32 *rule_locs)
 527 {
 528         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 529         int max_rules = dpaa2_eth_fs_count(priv);
 530         int i, j = 0;
 531
 532         switch (rxnfc->cmd) {
 533         case ETHTOOL_GRXFH:
 534                 /* we purposely ignore cmd->flow_type for now, because the
 535                  * classifier only supports a single set of fields for all
 536                  * protocols
 537                  */
 538                 rxnfc->data = priv->rx_hash_fields;
 539                 break;
 540         case ETHTOOL_GRXRINGS:
 541                 rxnfc->data = dpaa2_eth_queue_count(priv);
 542                 break;
 543         case ETHTOOL_GRXCLSRLCNT:
 544                 rxnfc->rule_cnt = 0;
 545                 for (i = 0; i < max_rules; i++)
 546                         if (priv->cls_rules[i].in_use)
 547                                 rxnfc->rule_cnt++;
 548                 rxnfc->data = max_rules;
 549                 break;
 550         case ETHTOOL_GRXCLSRULE:
 551                 if (rxnfc->fs.location >= max_rules)
 552                         return -EINVAL;
 553                 if (!priv->cls_rules[rxnfc->fs.location].in_use)
 554                         return -EINVAL;
 555                 rxnfc->fs = priv->cls_rules[rxnfc->fs.location].fs;
 556                 break;
 557         case ETHTOOL_GRXCLSRLALL:
 558                 for (i = 0; i < max_rules; i++) {
 559                         if (!priv->cls_rules[i].in_use)
 560                                 continue;
 561                         if (j == rxnfc->rule_cnt)
 562                                 return -EMSGSIZE;
 563                         rule_locs[j++] = i;
 564                 }
 565                 rxnfc->rule_cnt = j;
 566                 rxnfc->data = max_rules;
 567                 break;
 568         default:
 569                 return -EOPNOTSUPP;
 570         }
 571
 572         return 0;
 573 }
 574
 575 static int dpaa2_eth_set_rxnfc(struct net_device *net_dev,
 576                                struct ethtool_rxnfc *rxnfc)
 577 {
 578         int err = 0;
 579
 580         switch (rxnfc->cmd) {
 581         case ETHTOOL_SRXFH:
 582                 if ((rxnfc->data & DPAA2_RXH_SUPPORTED) != rxnfc->data)
 583                         return -EOPNOTSUPP;
 584                 err = dpaa2_eth_set_hash(net_dev, rxnfc->data);
 585                 break;
 586         case ETHTOOL_SRXCLSRLINS:
 587                 err = update_cls_rule(net_dev, &rxnfc->fs, rxnfc->fs.location);
 588                 break;
 589         case ETHTOOL_SRXCLSRLDEL:
 590                 err = update_cls_rule(net_dev, NULL, rxnfc->fs.location);
 591                 break;
 592         default:
 593                 err = -EOPNOTSUPP;
 594         }
 595
 596         return err;
 597 }
 598
 599 int dpaa2_phc_index = -1;
 600 EXPORT_SYMBOL(dpaa2_phc_index);
 601
 602 static int dpaa2_eth_get_ts_info(struct net_device *dev,
 603                                  struct ethtool_ts_info *info)
 604 {
 605         info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
 606                                 SOF_TIMESTAMPING_RX_HARDWARE |
 607                                 SOF_TIMESTAMPING_RAW_HARDWARE;
 608
 609         info->phc_index = dpaa2_phc_index;
 610
 611         info->tx_types = (1 << HWTSTAMP_TX_OFF) |
 612                          (1 << HWTSTAMP_TX_ON);
 613
 614         info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
 615                            (1 << HWTSTAMP_FILTER_ALL);
 616         return 0;
 617 }
 618
 619 const struct ethtool_ops dpaa2_ethtool_ops = {
 620         .get_drvinfo = dpaa2_eth_get_drvinfo,
 621         .get_link = ethtool_op_get_link,
 622         .get_link_ksettings = dpaa2_eth_get_link_ksettings,
 623         .set_link_ksettings = dpaa2_eth_set_link_ksettings,
 624         .get_sset_count = dpaa2_eth_get_sset_count,
 625         .get_ethtool_stats = dpaa2_eth_get_ethtool_stats,
 626         .get_strings = dpaa2_eth_get_strings,
 627         .get_rxnfc = dpaa2_eth_get_rxnfc,
 628         .set_rxnfc = dpaa2_eth_set_rxnfc,
 629         .get_ts_info = dpaa2_eth_get_ts_info,
 630 };