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         "[drv] xdp drop",
  49         "[drv] xdp tx",
  50         "[drv] xdp tx errors",
  51         "[drv] xdp redirect",
  52         /* FQ stats */
  53         "[qbman] rx pending frames",
  54         "[qbman] rx pending bytes",
  55         "[qbman] tx conf pending frames",
  56         "[qbman] tx conf pending bytes",
  57         "[qbman] buffer count",
  58 };
  59
  60 #define DPAA2_ETH_NUM_EXTRA_STATS       ARRAY_SIZE(dpaa2_ethtool_extras)
  61
  62 static void dpaa2_eth_get_drvinfo(struct net_device *net_dev,
  63                                   struct ethtool_drvinfo *drvinfo)
  64 {
  65         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
  66
  67         strlcpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver));
  68
  69         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
  70                  "%u.%u", priv->dpni_ver_major, priv->dpni_ver_minor);
  71
  72         strlcpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent),
  73                 sizeof(drvinfo->bus_info));
  74 }
  75
  76 static int
  77 dpaa2_eth_get_link_ksettings(struct net_device *net_dev,
  78                              struct ethtool_link_ksettings *link_settings)
  79 {
  80         struct dpni_link_state state = {0};
  81         int err = 0;
  82         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
  83
  84         err = dpni_get_link_state(priv->mc_io, 0, priv->mc_token, &state);
  85         if (err) {
  86                 netdev_err(net_dev, "ERROR %d getting link state\n", err);
  87                 goto out;
  88         }
  89
  90         /* At the moment, we have no way of interrogating the DPMAC
  91          * from the DPNI side - and for that matter there may exist
  92          * no DPMAC at all. So for now we just don't report anything
  93          * beyond the DPNI attributes.
  94          */
  95         if (state.options & DPNI_LINK_OPT_AUTONEG)
  96                 link_settings->base.autoneg = AUTONEG_ENABLE;
  97         if (!(state.options & DPNI_LINK_OPT_HALF_DUPLEX))
  98                 link_settings->base.duplex = DUPLEX_FULL;
  99         link_settings->base.speed = state.rate;
 100
 101 out:
 102         return err;
 103 }
 104
 105 #define DPNI_DYNAMIC_LINK_SET_VER_MAJOR         7
 106 #define DPNI_DYNAMIC_LINK_SET_VER_MINOR         1
 107 static int
 108 dpaa2_eth_set_link_ksettings(struct net_device *net_dev,
 109                              const struct ethtool_link_ksettings *link_settings)
 110 {
 111         struct dpni_link_cfg cfg = {0};
 112         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 113         int err = 0;
 114
 115         /* If using an older MC version, the DPNI must be down
 116          * in order to be able to change link settings. Taking steps to let
 117          * the user know that.
 118          */
 119         if (dpaa2_eth_cmp_dpni_ver(priv, DPNI_DYNAMIC_LINK_SET_VER_MAJOR,
 120                                    DPNI_DYNAMIC_LINK_SET_VER_MINOR) < 0) {
 121                 if (netif_running(net_dev)) {
 122                         netdev_info(net_dev, "Interface must be brought down first.\n");
 123                         return -EACCES;
 124                 }
 125         }
 126
 127         cfg.rate = link_settings->base.speed;
 128         if (link_settings->base.autoneg == AUTONEG_ENABLE)
 129                 cfg.options |= DPNI_LINK_OPT_AUTONEG;
 130         else
 131                 cfg.options &= ~DPNI_LINK_OPT_AUTONEG;
 132         if (link_settings->base.duplex  == DUPLEX_HALF)
 133                 cfg.options |= DPNI_LINK_OPT_HALF_DUPLEX;
 134         else
 135                 cfg.options &= ~DPNI_LINK_OPT_HALF_DUPLEX;
 136
 137         err = dpni_set_link_cfg(priv->mc_io, 0, priv->mc_token, &cfg);
 138         if (err)
 139                 /* ethtool will be loud enough if we return an error; no point
 140                  * in putting our own error message on the console by default
 141                  */
 142                 netdev_dbg(net_dev, "ERROR %d setting link cfg\n", err);
 143
 144         return err;
 145 }
 146
 147 static void dpaa2_eth_get_strings(struct net_device *netdev, u32 stringset,
 148                                   u8 *data)
 149 {
 150         u8 *p = data;
 151         int i;
 152
 153         switch (stringset) {
 154         case ETH_SS_STATS:
 155                 for (i = 0; i < DPAA2_ETH_NUM_STATS; i++) {
 156                         strlcpy(p, dpaa2_ethtool_stats[i], ETH_GSTRING_LEN);
 157                         p += ETH_GSTRING_LEN;
 158                 }
 159                 for (i = 0; i < DPAA2_ETH_NUM_EXTRA_STATS; i++) {
 160                         strlcpy(p, dpaa2_ethtool_extras[i], ETH_GSTRING_LEN);
 161                         p += ETH_GSTRING_LEN;
 162                 }
 163                 break;
 164         }
 165 }
 166
 167 static int dpaa2_eth_get_sset_count(struct net_device *net_dev, int sset)
 168 {
 169         switch (sset) {
 170         case ETH_SS_STATS: /* ethtool_get_stats(), ethtool_get_drvinfo() */
 171                 return DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS;
 172         default:
 173                 return -EOPNOTSUPP;
 174         }
 175 }
 176
 177 /** Fill in hardware counters, as returned by MC.
 178  */
 179 static void dpaa2_eth_get_ethtool_stats(struct net_device *net_dev,
 180                                         struct ethtool_stats *stats,
 181                                         u64 *data)
 182 {
 183         int i = 0;
 184         int j, k, err;
 185         int num_cnt;
 186         union dpni_statistics dpni_stats;
 187         u32 fcnt, bcnt;
 188         u32 fcnt_rx_total = 0, fcnt_tx_total = 0;
 189         u32 bcnt_rx_total = 0, bcnt_tx_total = 0;
 190         u32 buf_cnt;
 191         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 192         struct dpaa2_eth_drv_stats *extras;
 193         struct dpaa2_eth_ch_stats *ch_stats;
 194
 195         memset(data, 0,
 196                sizeof(u64) * (DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS));
 197
 198         /* Print standard counters, from DPNI statistics */
 199         for (j = 0; j <= 2; j++) {
 200                 err = dpni_get_statistics(priv->mc_io, 0, priv->mc_token,
 201                                           j, &dpni_stats);
 202                 if (err != 0)
 203                         netdev_warn(net_dev, "dpni_get_stats(%d) failed\n", j);
 204                 switch (j) {
 205                 case 0:
 206                         num_cnt = sizeof(dpni_stats.page_0) / sizeof(u64);
 207                         break;
 208                 case 1:
 209                         num_cnt = sizeof(dpni_stats.page_1) / sizeof(u64);
 210                         break;
 211                 case 2:
 212                         num_cnt = sizeof(dpni_stats.page_2) / sizeof(u64);
 213                         break;
 214                 }
 215                 for (k = 0; k < num_cnt; k++)
 216                         *(data + i++) = dpni_stats.raw.counter[k];
 217         }
 218
 219         /* Print per-cpu extra stats */
 220         for_each_online_cpu(k) {
 221                 extras = per_cpu_ptr(priv->percpu_extras, k);
 222                 for (j = 0; j < sizeof(*extras) / sizeof(__u64); j++)
 223                         *((__u64 *)data + i + j) += *((__u64 *)extras + j);
 224         }
 225         i += j;
 226
 227         /* Per-channel stats */
 228         for (k = 0; k < priv->num_channels; k++) {
 229                 ch_stats = &priv->channel[k]->stats;
 230                 for (j = 0; j < sizeof(*ch_stats) / sizeof(__u64); j++)
 231                         *((__u64 *)data + i + j) += *((__u64 *)ch_stats + j);
 232         }
 233         i += j;
 234
 235         for (j = 0; j < priv->num_fqs; j++) {
 236                 /* Print FQ instantaneous counts */
 237                 err = dpaa2_io_query_fq_count(NULL, priv->fq[j].fqid,
 238                                               &fcnt, &bcnt);
 239                 if (err) {
 240                         netdev_warn(net_dev, "FQ query error %d", err);
 241                         return;
 242                 }
 243
 244                 if (priv->fq[j].type == DPAA2_TX_CONF_FQ) {
 245                         fcnt_tx_total += fcnt;
 246                         bcnt_tx_total += bcnt;
 247                 } else {
 248                         fcnt_rx_total += fcnt;
 249                         bcnt_rx_total += bcnt;
 250                 }
 251         }
 252
 253         *(data + i++) = fcnt_rx_total;
 254         *(data + i++) = bcnt_rx_total;
 255         *(data + i++) = fcnt_tx_total;
 256         *(data + i++) = bcnt_tx_total;
 257
 258         err = dpaa2_io_query_bp_count(NULL, priv->bpid, &buf_cnt);
 259         if (err) {
 260                 netdev_warn(net_dev, "Buffer count query error %d\n", err);
 261                 return;
 262         }
 263         *(data + i++) = buf_cnt;
 264 }
 265
 266 static int prep_eth_rule(struct ethhdr *eth_value, struct ethhdr *eth_mask,
 267                          void *key, void *mask, u64 *fields)
 268 {
 269         int off;
 270
 271         if (eth_mask->h_proto) {
 272                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE);
 273                 *(__be16 *)(key + off) = eth_value->h_proto;
 274                 *(__be16 *)(mask + off) = eth_mask->h_proto;
 275                 *fields |= DPAA2_ETH_DIST_ETHTYPE;
 276         }
 277
 278         if (!is_zero_ether_addr(eth_mask->h_source)) {
 279                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_SA);
 280                 ether_addr_copy(key + off, eth_value->h_source);
 281                 ether_addr_copy(mask + off, eth_mask->h_source);
 282                 *fields |= DPAA2_ETH_DIST_ETHSRC;
 283         }
 284
 285         if (!is_zero_ether_addr(eth_mask->h_dest)) {
 286                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_DA);
 287                 ether_addr_copy(key + off, eth_value->h_dest);
 288                 ether_addr_copy(mask + off, eth_mask->h_dest);
 289                 *fields |= DPAA2_ETH_DIST_ETHDST;
 290         }
 291
 292         return 0;
 293 }
 294
 295 static int prep_uip_rule(struct ethtool_usrip4_spec *uip_value,
 296                          struct ethtool_usrip4_spec *uip_mask,
 297                          void *key, void *mask, u64 *fields)
 298 {
 299         int off;
 300         u32 tmp_value, tmp_mask;
 301
 302         if (uip_mask->tos || uip_mask->ip_ver)
 303                 return -EOPNOTSUPP;
 304
 305         if (uip_mask->ip4src) {
 306                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_SRC);
 307                 *(__be32 *)(key + off) = uip_value->ip4src;
 308                 *(__be32 *)(mask + off) = uip_mask->ip4src;
 309                 *fields |= DPAA2_ETH_DIST_IPSRC;
 310         }
 311
 312         if (uip_mask->ip4dst) {
 313                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_DST);
 314                 *(__be32 *)(key + off) = uip_value->ip4dst;
 315                 *(__be32 *)(mask + off) = uip_mask->ip4dst;
 316                 *fields |= DPAA2_ETH_DIST_IPDST;
 317         }
 318
 319         if (uip_mask->proto) {
 320                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_PROTO);
 321                 *(u8 *)(key + off) = uip_value->proto;
 322                 *(u8 *)(mask + off) = uip_mask->proto;
 323                 *fields |= DPAA2_ETH_DIST_IPPROTO;
 324         }
 325
 326         if (uip_mask->l4_4_bytes) {
 327                 tmp_value = be32_to_cpu(uip_value->l4_4_bytes);
 328                 tmp_mask = be32_to_cpu(uip_mask->l4_4_bytes);
 329
 330                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
 331                 *(__be16 *)(key + off) = htons(tmp_value >> 16);
 332                 *(__be16 *)(mask + off) = htons(tmp_mask >> 16);
 333                 *fields |= DPAA2_ETH_DIST_L4SRC;
 334
 335                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
 336                 *(__be16 *)(key + off) = htons(tmp_value & 0xFFFF);
 337                 *(__be16 *)(mask + off) = htons(tmp_mask & 0xFFFF);
 338                 *fields |= DPAA2_ETH_DIST_L4DST;
 339         }
 340
 341         /* Only apply the rule for IPv4 frames */
 342         off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE);
 343         *(__be16 *)(key + off) = htons(ETH_P_IP);
 344         *(__be16 *)(mask + off) = htons(0xFFFF);
 345         *fields |= DPAA2_ETH_DIST_ETHTYPE;
 346
 347         return 0;
 348 }
 349
 350 static int prep_l4_rule(struct ethtool_tcpip4_spec *l4_value,
 351                         struct ethtool_tcpip4_spec *l4_mask,
 352                         void *key, void *mask, u8 l4_proto, u64 *fields)
 353 {
 354         int off;
 355
 356         if (l4_mask->tos)
 357                 return -EOPNOTSUPP;
 358
 359         if (l4_mask->ip4src) {
 360                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_SRC);
 361                 *(__be32 *)(key + off) = l4_value->ip4src;
 362                 *(__be32 *)(mask + off) = l4_mask->ip4src;
 363                 *fields |= DPAA2_ETH_DIST_IPSRC;
 364         }
 365
 366         if (l4_mask->ip4dst) {
 367                 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_DST);
 368                 *(__be32 *)(key + off) = l4_value->ip4dst;
 369                 *(__be32 *)(mask + off) = l4_mask->ip4dst;
 370                 *fields |= DPAA2_ETH_DIST_IPDST;
 371         }
 372
 373         if (l4_mask->psrc) {
 374                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_SRC);
 375                 *(__be16 *)(key + off) = l4_value->psrc;
 376                 *(__be16 *)(mask + off) = l4_mask->psrc;
 377                 *fields |= DPAA2_ETH_DIST_L4SRC;
 378         }
 379
 380         if (l4_mask->pdst) {
 381                 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_DST);
 382                 *(__be16 *)(key + off) = l4_value->pdst;
 383                 *(__be16 *)(mask + off) = l4_mask->pdst;
 384                 *fields |= DPAA2_ETH_DIST_L4DST;
 385         }
 386
 387         /* Only apply the rule for IPv4 frames with the specified L4 proto */
 388         off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE);
 389         *(__be16 *)(key + off) = htons(ETH_P_IP);
 390         *(__be16 *)(mask + off) = htons(0xFFFF);
 391         *fields |= DPAA2_ETH_DIST_ETHTYPE;
 392
 393         off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_PROTO);
 394         *(u8 *)(key + off) = l4_proto;
 395         *(u8 *)(mask + off) = 0xFF;
 396         *fields |= DPAA2_ETH_DIST_IPPROTO;
 397
 398         return 0;
 399 }
 400
 401 static int prep_ext_rule(struct ethtool_flow_ext *ext_value,
 402                          struct ethtool_flow_ext *ext_mask,
 403                          void *key, void *mask, u64 *fields)
 404 {
 405         int off;
 406
 407         if (ext_mask->vlan_etype)
 408                 return -EOPNOTSUPP;
 409
 410         if (ext_mask->vlan_tci) {
 411                 off = dpaa2_eth_cls_fld_off(NET_PROT_VLAN, NH_FLD_VLAN_TCI);
 412                 *(__be16 *)(key + off) = ext_value->vlan_tci;
 413                 *(__be16 *)(mask + off) = ext_mask->vlan_tci;
 414                 *fields |= DPAA2_ETH_DIST_VLAN;
 415         }
 416
 417         return 0;
 418 }
 419
 420 static int prep_mac_ext_rule(struct ethtool_flow_ext *ext_value,
 421                              struct ethtool_flow_ext *ext_mask,
 422                              void *key, void *mask, u64 *fields)
 423 {
 424         int off;
 425
 426         if (!is_zero_ether_addr(ext_mask->h_dest)) {
 427                 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_DA);
 428                 ether_addr_copy(key + off, ext_value->h_dest);
 429                 ether_addr_copy(mask + off, ext_mask->h_dest);
 430                 *fields |= DPAA2_ETH_DIST_ETHDST;
 431         }
 432
 433         return 0;
 434 }
 435
 436 static int prep_cls_rule(struct ethtool_rx_flow_spec *fs, void *key, void *mask,
 437                          u64 *fields)
 438 {
 439         int err;
 440
 441         switch (fs->flow_type & 0xFF) {
 442         case ETHER_FLOW:
 443                 err = prep_eth_rule(&fs->h_u.ether_spec, &fs->m_u.ether_spec,
 444                                     key, mask, fields);
 445                 break;
 446         case IP_USER_FLOW:
 447                 err = prep_uip_rule(&fs->h_u.usr_ip4_spec,
 448                                     &fs->m_u.usr_ip4_spec, key, mask, fields);
 449                 break;
 450         case TCP_V4_FLOW:
 451                 err = prep_l4_rule(&fs->h_u.tcp_ip4_spec, &fs->m_u.tcp_ip4_spec,
 452                                    key, mask, IPPROTO_TCP, fields);
 453                 break;
 454         case UDP_V4_FLOW:
 455                 err = prep_l4_rule(&fs->h_u.udp_ip4_spec, &fs->m_u.udp_ip4_spec,
 456                                    key, mask, IPPROTO_UDP, fields);
 457                 break;
 458         case SCTP_V4_FLOW:
 459                 err = prep_l4_rule(&fs->h_u.sctp_ip4_spec,
 460                                    &fs->m_u.sctp_ip4_spec, key, mask,
 461                                    IPPROTO_SCTP, fields);
 462                 break;
 463         default:
 464                 return -EOPNOTSUPP;
 465         }
 466
 467         if (err)
 468                 return err;
 469
 470         if (fs->flow_type & FLOW_EXT) {
 471                 err = prep_ext_rule(&fs->h_ext, &fs->m_ext, key, mask, fields);
 472                 if (err)
 473                         return err;
 474         }
 475
 476         if (fs->flow_type & FLOW_MAC_EXT) {
 477                 err = prep_mac_ext_rule(&fs->h_ext, &fs->m_ext, key, mask,
 478                                         fields);
 479                 if (err)
 480                         return err;
 481         }
 482
 483         return 0;
 484 }
 485
 486 static int do_cls_rule(struct net_device *net_dev,
 487                        struct ethtool_rx_flow_spec *fs,
 488                        bool add)
 489 {
 490         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 491         struct device *dev = net_dev->dev.parent;
 492         struct dpni_rule_cfg rule_cfg = { 0 };
 493         struct dpni_fs_action_cfg fs_act = { 0 };
 494         dma_addr_t key_iova;
 495         u64 fields = 0;
 496         void *key_buf;
 497         int err;
 498
 499         if (fs->ring_cookie != RX_CLS_FLOW_DISC &&
 500             fs->ring_cookie >= dpaa2_eth_queue_count(priv))
 501                 return -EINVAL;
 502
 503         rule_cfg.key_size = dpaa2_eth_cls_key_size(DPAA2_ETH_DIST_ALL);
 504
 505         /* allocate twice the key size, for the actual key and for mask */
 506         key_buf = kzalloc(rule_cfg.key_size * 2, GFP_KERNEL);
 507         if (!key_buf)
 508                 return -ENOMEM;
 509
 510         /* Fill the key and mask memory areas */
 511         err = prep_cls_rule(fs, key_buf, key_buf + rule_cfg.key_size, &fields);
 512         if (err)
 513                 goto free_mem;
 514
 515         if (!dpaa2_eth_fs_mask_enabled(priv)) {
 516                 /* Masking allows us to configure a maximal key during init and
 517                  * use it for all flow steering rules. Without it, we include
 518                  * in the key only the fields actually used, so we need to
 519                  * extract the others from the final key buffer.
 520                  *
 521                  * Program the FS key if needed, or return error if previously
 522                  * set key can't be used for the current rule. User needs to
 523                  * delete existing rules in this case to allow for the new one.
 524                  */
 525                 if (!priv->rx_cls_fields) {
 526                         err = dpaa2_eth_set_cls(net_dev, fields);
 527                         if (err)
 528                                 goto free_mem;
 529
 530                         priv->rx_cls_fields = fields;
 531                 } else if (priv->rx_cls_fields != fields) {
 532                         netdev_err(net_dev, "No support for multiple FS keys, need to delete existing rules\n");
 533                         err = -EOPNOTSUPP;
 534                         goto free_mem;
 535                 }
 536
 537                 dpaa2_eth_cls_trim_rule(key_buf, fields);
 538                 rule_cfg.key_size = dpaa2_eth_cls_key_size(fields);
 539         }
 540
 541         key_iova = dma_map_single(dev, key_buf, rule_cfg.key_size * 2,
 542                                   DMA_TO_DEVICE);
 543         if (dma_mapping_error(dev, key_iova)) {
 544                 err = -ENOMEM;
 545                 goto free_mem;
 546         }
 547
 548         rule_cfg.key_iova = key_iova;
 549         if (dpaa2_eth_fs_mask_enabled(priv))
 550                 rule_cfg.mask_iova = key_iova + rule_cfg.key_size;
 551
 552         if (add) {
 553                 if (fs->ring_cookie == RX_CLS_FLOW_DISC)
 554                         fs_act.options |= DPNI_FS_OPT_DISCARD;
 555                 else
 556                         fs_act.flow_id = fs->ring_cookie;
 557                 err = dpni_add_fs_entry(priv->mc_io, 0, priv->mc_token, 0,
 558                                         fs->location, &rule_cfg, &fs_act);
 559         } else {
 560                 err = dpni_remove_fs_entry(priv->mc_io, 0, priv->mc_token, 0,
 561                                            &rule_cfg);
 562         }
 563
 564         dma_unmap_single(dev, key_iova, rule_cfg.key_size * 2, DMA_TO_DEVICE);
 565
 566 free_mem:
 567         kfree(key_buf);
 568
 569         return err;
 570 }
 571
 572 static int num_rules(struct dpaa2_eth_priv *priv)
 573 {
 574         int i, rules = 0;
 575
 576         for (i = 0; i < dpaa2_eth_fs_count(priv); i++)
 577                 if (priv->cls_rules[i].in_use)
 578                         rules++;
 579
 580         return rules;
 581 }
 582
 583 static int update_cls_rule(struct net_device *net_dev,
 584                            struct ethtool_rx_flow_spec *new_fs,
 585                            int location)
 586 {
 587         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 588         struct dpaa2_eth_cls_rule *rule;
 589         int err = -EINVAL;
 590
 591         if (!priv->rx_cls_enabled)
 592                 return -EOPNOTSUPP;
 593
 594         if (location >= dpaa2_eth_fs_count(priv))
 595                 return -EINVAL;
 596
 597         rule = &priv->cls_rules[location];
 598
 599         /* If a rule is present at the specified location, delete it. */
 600         if (rule->in_use) {
 601                 err = do_cls_rule(net_dev, &rule->fs, false);
 602                 if (err)
 603                         return err;
 604
 605                 rule->in_use = 0;
 606
 607                 if (!dpaa2_eth_fs_mask_enabled(priv) && !num_rules(priv))
 608                         priv->rx_cls_fields = 0;
 609         }
 610
 611         /* If no new entry to add, return here */
 612         if (!new_fs)
 613                 return err;
 614
 615         err = do_cls_rule(net_dev, new_fs, true);
 616         if (err)
 617                 return err;
 618
 619         rule->in_use = 1;
 620         rule->fs = *new_fs;
 621
 622         return 0;
 623 }
 624
 625 static int dpaa2_eth_get_rxnfc(struct net_device *net_dev,
 626                                struct ethtool_rxnfc *rxnfc, u32 *rule_locs)
 627 {
 628         struct dpaa2_eth_priv *priv = netdev_priv(net_dev);
 629         int max_rules = dpaa2_eth_fs_count(priv);
 630         int i, j = 0;
 631
 632         switch (rxnfc->cmd) {
 633         case ETHTOOL_GRXFH:
 634                 /* we purposely ignore cmd->flow_type for now, because the
 635                  * classifier only supports a single set of fields for all
 636                  * protocols
 637                  */
 638                 rxnfc->data = priv->rx_hash_fields;
 639                 break;
 640         case ETHTOOL_GRXRINGS:
 641                 rxnfc->data = dpaa2_eth_queue_count(priv);
 642                 break;
 643         case ETHTOOL_GRXCLSRLCNT:
 644                 rxnfc->rule_cnt = 0;
 645                 rxnfc->rule_cnt = num_rules(priv);
 646                 rxnfc->data = max_rules;
 647                 break;
 648         case ETHTOOL_GRXCLSRULE:
 649                 if (rxnfc->fs.location >= max_rules)
 650                         return -EINVAL;
 651                 if (!priv->cls_rules[rxnfc->fs.location].in_use)
 652                         return -EINVAL;
 653                 rxnfc->fs = priv->cls_rules[rxnfc->fs.location].fs;
 654                 break;
 655         case ETHTOOL_GRXCLSRLALL:
 656                 for (i = 0; i < max_rules; i++) {
 657                         if (!priv->cls_rules[i].in_use)
 658                                 continue;
 659                         if (j == rxnfc->rule_cnt)
 660                                 return -EMSGSIZE;
 661                         rule_locs[j++] = i;
 662                 }
 663                 rxnfc->rule_cnt = j;
 664                 rxnfc->data = max_rules;
 665                 break;
 666         default:
 667                 return -EOPNOTSUPP;
 668         }
 669
 670         return 0;
 671 }
 672
 673 static int dpaa2_eth_set_rxnfc(struct net_device *net_dev,
 674                                struct ethtool_rxnfc *rxnfc)
 675 {
 676         int err = 0;
 677
 678         switch (rxnfc->cmd) {
 679         case ETHTOOL_SRXFH:
 680                 if ((rxnfc->data & DPAA2_RXH_SUPPORTED) != rxnfc->data)
 681                         return -EOPNOTSUPP;
 682                 err = dpaa2_eth_set_hash(net_dev, rxnfc->data);
 683                 break;
 684         case ETHTOOL_SRXCLSRLINS:
 685                 err = update_cls_rule(net_dev, &rxnfc->fs, rxnfc->fs.location);
 686                 break;
 687         case ETHTOOL_SRXCLSRLDEL:
 688                 err = update_cls_rule(net_dev, NULL, rxnfc->fs.location);
 689                 break;
 690         default:
 691                 err = -EOPNOTSUPP;
 692         }
 693
 694         return err;
 695 }
 696
 697 int dpaa2_phc_index = -1;
 698 EXPORT_SYMBOL(dpaa2_phc_index);
 699
 700 static int dpaa2_eth_get_ts_info(struct net_device *dev,
 701                                  struct ethtool_ts_info *info)
 702 {
 703         info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE |
 704                                 SOF_TIMESTAMPING_RX_HARDWARE |
 705                                 SOF_TIMESTAMPING_RAW_HARDWARE;
 706
 707         info->phc_index = dpaa2_phc_index;
 708
 709         info->tx_types = (1 << HWTSTAMP_TX_OFF) |
 710                          (1 << HWTSTAMP_TX_ON);
 711
 712         info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
 713                            (1 << HWTSTAMP_FILTER_ALL);
 714         return 0;
 715 }
 716
 717 const struct ethtool_ops dpaa2_ethtool_ops = {
 718         .get_drvinfo = dpaa2_eth_get_drvinfo,
 719         .get_link = ethtool_op_get_link,
 720         .get_link_ksettings = dpaa2_eth_get_link_ksettings,
 721         .set_link_ksettings = dpaa2_eth_set_link_ksettings,
 722         .get_sset_count = dpaa2_eth_get_sset_count,
 723         .get_ethtool_stats = dpaa2_eth_get_ethtool_stats,
 724         .get_strings = dpaa2_eth_get_strings,
 725         .get_rxnfc = dpaa2_eth_get_rxnfc,
 726         .set_rxnfc = dpaa2_eth_set_rxnfc,
 727         .get_ts_info = dpaa2_eth_get_ts_info,
 728 };