1 // SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) 2 /* Copyright 2014-2016 Freescale Semiconductor Inc. 3 * Copyright 2016-2022 NXP 4 */ 5 6 #include <linux/net_tstamp.h> 7 #include <linux/nospec.h> 8 9 #include "dpni.h" /* DPNI_LINK_OPT_* */ 10 #include "dpaa2-eth.h" 11 12 /* To be kept in sync with DPNI statistics */ 13 static char dpaa2_ethtool_stats[][ETH_GSTRING_LEN] = { 14 "[hw] rx frames", 15 "[hw] rx bytes", 16 "[hw] rx mcast frames", 17 "[hw] rx mcast bytes", 18 "[hw] rx bcast frames", 19 "[hw] rx bcast bytes", 20 "[hw] tx frames", 21 "[hw] tx bytes", 22 "[hw] tx mcast frames", 23 "[hw] tx mcast bytes", 24 "[hw] tx bcast frames", 25 "[hw] tx bcast bytes", 26 "[hw] rx filtered frames", 27 "[hw] rx discarded frames", 28 "[hw] rx nobuffer discards", 29 "[hw] tx discarded frames", 30 "[hw] tx confirmed frames", 31 "[hw] tx dequeued bytes", 32 "[hw] tx dequeued frames", 33 "[hw] tx rejected bytes", 34 "[hw] tx rejected frames", 35 "[hw] tx pending frames", 36 }; 37 38 #define DPAA2_ETH_NUM_STATS ARRAY_SIZE(dpaa2_ethtool_stats) 39 40 static char dpaa2_ethtool_extras[][ETH_GSTRING_LEN] = { 41 /* per-cpu stats */ 42 "[drv] tx conf frames", 43 "[drv] tx conf bytes", 44 "[drv] tx sg frames", 45 "[drv] tx sg bytes", 46 "[drv] tx tso frames", 47 "[drv] tx tso bytes", 48 "[drv] rx sg frames", 49 "[drv] rx sg bytes", 50 "[drv] tx converted sg frames", 51 "[drv] tx converted sg bytes", 52 "[drv] enqueue portal busy", 53 /* Channel stats */ 54 "[drv] dequeue portal busy", 55 "[drv] channel pull errors", 56 "[drv] cdan", 57 "[drv] xdp drop", 58 "[drv] xdp tx", 59 "[drv] xdp tx errors", 60 "[drv] xdp redirect", 61 /* FQ stats */ 62 "[qbman] rx pending frames", 63 "[qbman] rx pending bytes", 64 "[qbman] tx conf pending frames", 65 "[qbman] tx conf pending bytes", 66 "[qbman] buffer count", 67 }; 68 69 #define DPAA2_ETH_NUM_EXTRA_STATS ARRAY_SIZE(dpaa2_ethtool_extras) 70 71 static void dpaa2_eth_get_drvinfo(struct net_device *net_dev, 72 struct ethtool_drvinfo *drvinfo) 73 { 74 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 75 76 strscpy(drvinfo->driver, KBUILD_MODNAME, sizeof(drvinfo->driver)); 77 78 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 79 "%u.%u", priv->dpni_ver_major, priv->dpni_ver_minor); 80 81 strscpy(drvinfo->bus_info, dev_name(net_dev->dev.parent->parent), 82 sizeof(drvinfo->bus_info)); 83 } 84 85 static int dpaa2_eth_nway_reset(struct net_device *net_dev) 86 { 87 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 88 int err = -EOPNOTSUPP; 89 90 mutex_lock(&priv->mac_lock); 91 92 if (dpaa2_eth_is_type_phy(priv)) 93 err = phylink_ethtool_nway_reset(priv->mac->phylink); 94 95 mutex_unlock(&priv->mac_lock); 96 97 return err; 98 } 99 100 static int 101 dpaa2_eth_get_link_ksettings(struct net_device *net_dev, 102 struct ethtool_link_ksettings *link_settings) 103 { 104 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 105 int err; 106 107 mutex_lock(&priv->mac_lock); 108 109 if (dpaa2_eth_is_type_phy(priv)) { 110 err = phylink_ethtool_ksettings_get(priv->mac->phylink, 111 link_settings); 112 mutex_unlock(&priv->mac_lock); 113 return err; 114 } 115 116 mutex_unlock(&priv->mac_lock); 117 118 link_settings->base.autoneg = AUTONEG_DISABLE; 119 if (!(priv->link_state.options & DPNI_LINK_OPT_HALF_DUPLEX)) 120 link_settings->base.duplex = DUPLEX_FULL; 121 link_settings->base.speed = priv->link_state.rate; 122 123 return 0; 124 } 125 126 static int 127 dpaa2_eth_set_link_ksettings(struct net_device *net_dev, 128 const struct ethtool_link_ksettings *link_settings) 129 { 130 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 131 int err = -EOPNOTSUPP; 132 133 mutex_lock(&priv->mac_lock); 134 135 if (dpaa2_eth_is_type_phy(priv)) 136 err = phylink_ethtool_ksettings_set(priv->mac->phylink, 137 link_settings); 138 139 mutex_unlock(&priv->mac_lock); 140 141 return err; 142 } 143 144 static void dpaa2_eth_get_pauseparam(struct net_device *net_dev, 145 struct ethtool_pauseparam *pause) 146 { 147 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 148 u64 link_options = priv->link_state.options; 149 150 mutex_lock(&priv->mac_lock); 151 152 if (dpaa2_eth_is_type_phy(priv)) { 153 phylink_ethtool_get_pauseparam(priv->mac->phylink, pause); 154 mutex_unlock(&priv->mac_lock); 155 return; 156 } 157 158 mutex_unlock(&priv->mac_lock); 159 160 pause->rx_pause = dpaa2_eth_rx_pause_enabled(link_options); 161 pause->tx_pause = dpaa2_eth_tx_pause_enabled(link_options); 162 pause->autoneg = AUTONEG_DISABLE; 163 } 164 165 static int dpaa2_eth_set_pauseparam(struct net_device *net_dev, 166 struct ethtool_pauseparam *pause) 167 { 168 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 169 struct dpni_link_cfg cfg = {0}; 170 int err; 171 172 if (!dpaa2_eth_has_pause_support(priv)) { 173 netdev_info(net_dev, "No pause frame support for DPNI version < %d.%d\n", 174 DPNI_PAUSE_VER_MAJOR, DPNI_PAUSE_VER_MINOR); 175 return -EOPNOTSUPP; 176 } 177 178 mutex_lock(&priv->mac_lock); 179 180 if (dpaa2_eth_is_type_phy(priv)) { 181 err = phylink_ethtool_set_pauseparam(priv->mac->phylink, 182 pause); 183 mutex_unlock(&priv->mac_lock); 184 return err; 185 } 186 187 mutex_unlock(&priv->mac_lock); 188 189 if (pause->autoneg) 190 return -EOPNOTSUPP; 191 192 cfg.rate = priv->link_state.rate; 193 cfg.options = priv->link_state.options; 194 if (pause->rx_pause) 195 cfg.options |= DPNI_LINK_OPT_PAUSE; 196 else 197 cfg.options &= ~DPNI_LINK_OPT_PAUSE; 198 if (!!pause->rx_pause ^ !!pause->tx_pause) 199 cfg.options |= DPNI_LINK_OPT_ASYM_PAUSE; 200 else 201 cfg.options &= ~DPNI_LINK_OPT_ASYM_PAUSE; 202 203 if (cfg.options == priv->link_state.options) 204 return 0; 205 206 err = dpni_set_link_cfg(priv->mc_io, 0, priv->mc_token, &cfg); 207 if (err) { 208 netdev_err(net_dev, "dpni_set_link_state failed\n"); 209 return err; 210 } 211 212 priv->link_state.options = cfg.options; 213 214 return 0; 215 } 216 217 static void dpaa2_eth_get_strings(struct net_device *netdev, u32 stringset, 218 u8 *data) 219 { 220 u8 *p = data; 221 int i; 222 223 switch (stringset) { 224 case ETH_SS_STATS: 225 for (i = 0; i < DPAA2_ETH_NUM_STATS; i++) { 226 strscpy(p, dpaa2_ethtool_stats[i], ETH_GSTRING_LEN); 227 p += ETH_GSTRING_LEN; 228 } 229 for (i = 0; i < DPAA2_ETH_NUM_EXTRA_STATS; i++) { 230 strscpy(p, dpaa2_ethtool_extras[i], ETH_GSTRING_LEN); 231 p += ETH_GSTRING_LEN; 232 } 233 dpaa2_mac_get_strings(p); 234 break; 235 } 236 } 237 238 static int dpaa2_eth_get_sset_count(struct net_device *net_dev, int sset) 239 { 240 switch (sset) { 241 case ETH_SS_STATS: /* ethtool_get_stats(), ethtool_get_drvinfo() */ 242 return DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS + 243 dpaa2_mac_get_sset_count(); 244 default: 245 return -EOPNOTSUPP; 246 } 247 } 248 249 /** Fill in hardware counters, as returned by MC. 250 */ 251 static void dpaa2_eth_get_ethtool_stats(struct net_device *net_dev, 252 struct ethtool_stats *stats, 253 u64 *data) 254 { 255 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 256 union dpni_statistics dpni_stats; 257 int dpni_stats_page_size[DPNI_STATISTICS_CNT] = { 258 sizeof(dpni_stats.page_0), 259 sizeof(dpni_stats.page_1), 260 sizeof(dpni_stats.page_2), 261 sizeof(dpni_stats.page_3), 262 sizeof(dpni_stats.page_4), 263 sizeof(dpni_stats.page_5), 264 sizeof(dpni_stats.page_6), 265 }; 266 u32 fcnt_rx_total = 0, fcnt_tx_total = 0; 267 u32 bcnt_rx_total = 0, bcnt_tx_total = 0; 268 struct dpaa2_eth_ch_stats *ch_stats; 269 struct dpaa2_eth_drv_stats *extras; 270 u32 buf_cnt, buf_cnt_total = 0; 271 int j, k, err, num_cnt, i = 0; 272 u32 fcnt, bcnt; 273 274 memset(data, 0, 275 sizeof(u64) * (DPAA2_ETH_NUM_STATS + DPAA2_ETH_NUM_EXTRA_STATS)); 276 277 /* Print standard counters, from DPNI statistics */ 278 for (j = 0; j <= 6; j++) { 279 /* We're not interested in pages 4 & 5 for now */ 280 if (j == 4 || j == 5) 281 continue; 282 err = dpni_get_statistics(priv->mc_io, 0, priv->mc_token, 283 j, &dpni_stats); 284 if (err == -EINVAL) 285 /* Older firmware versions don't support all pages */ 286 memset(&dpni_stats, 0, sizeof(dpni_stats)); 287 else if (err) 288 netdev_warn(net_dev, "dpni_get_stats(%d) failed\n", j); 289 290 num_cnt = dpni_stats_page_size[j] / sizeof(u64); 291 for (k = 0; k < num_cnt; k++) 292 *(data + i++) = dpni_stats.raw.counter[k]; 293 } 294 295 /* Print per-cpu extra stats */ 296 for_each_online_cpu(k) { 297 extras = per_cpu_ptr(priv->percpu_extras, k); 298 for (j = 0; j < sizeof(*extras) / sizeof(__u64); j++) 299 *((__u64 *)data + i + j) += *((__u64 *)extras + j); 300 } 301 i += j; 302 303 /* Per-channel stats */ 304 for (k = 0; k < priv->num_channels; k++) { 305 ch_stats = &priv->channel[k]->stats; 306 for (j = 0; j < DPAA2_ETH_CH_STATS; j++) 307 *((__u64 *)data + i + j) += *((__u64 *)ch_stats + j); 308 } 309 i += j; 310 311 for (j = 0; j < priv->num_fqs; j++) { 312 /* Print FQ instantaneous counts */ 313 err = dpaa2_io_query_fq_count(NULL, priv->fq[j].fqid, 314 &fcnt, &bcnt); 315 if (err) { 316 netdev_warn(net_dev, "FQ query error %d", err); 317 return; 318 } 319 320 if (priv->fq[j].type == DPAA2_TX_CONF_FQ) { 321 fcnt_tx_total += fcnt; 322 bcnt_tx_total += bcnt; 323 } else { 324 fcnt_rx_total += fcnt; 325 bcnt_rx_total += bcnt; 326 } 327 } 328 329 *(data + i++) = fcnt_rx_total; 330 *(data + i++) = bcnt_rx_total; 331 *(data + i++) = fcnt_tx_total; 332 *(data + i++) = bcnt_tx_total; 333 334 for (j = 0; j < priv->num_bps; j++) { 335 err = dpaa2_io_query_bp_count(NULL, priv->bp[j]->bpid, &buf_cnt); 336 if (err) { 337 netdev_warn(net_dev, "Buffer count query error %d\n", err); 338 return; 339 } 340 buf_cnt_total += buf_cnt; 341 } 342 *(data + i++) = buf_cnt_total; 343 344 mutex_lock(&priv->mac_lock); 345 346 if (dpaa2_eth_has_mac(priv)) 347 dpaa2_mac_get_ethtool_stats(priv->mac, data + i); 348 349 mutex_unlock(&priv->mac_lock); 350 } 351 352 static int dpaa2_eth_prep_eth_rule(struct ethhdr *eth_value, struct ethhdr *eth_mask, 353 void *key, void *mask, u64 *fields) 354 { 355 int off; 356 357 if (eth_mask->h_proto) { 358 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE); 359 *(__be16 *)(key + off) = eth_value->h_proto; 360 *(__be16 *)(mask + off) = eth_mask->h_proto; 361 *fields |= DPAA2_ETH_DIST_ETHTYPE; 362 } 363 364 if (!is_zero_ether_addr(eth_mask->h_source)) { 365 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_SA); 366 ether_addr_copy(key + off, eth_value->h_source); 367 ether_addr_copy(mask + off, eth_mask->h_source); 368 *fields |= DPAA2_ETH_DIST_ETHSRC; 369 } 370 371 if (!is_zero_ether_addr(eth_mask->h_dest)) { 372 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_DA); 373 ether_addr_copy(key + off, eth_value->h_dest); 374 ether_addr_copy(mask + off, eth_mask->h_dest); 375 *fields |= DPAA2_ETH_DIST_ETHDST; 376 } 377 378 return 0; 379 } 380 381 static int dpaa2_eth_prep_uip_rule(struct ethtool_usrip4_spec *uip_value, 382 struct ethtool_usrip4_spec *uip_mask, 383 void *key, void *mask, u64 *fields) 384 { 385 int off; 386 u32 tmp_value, tmp_mask; 387 388 if (uip_mask->tos || uip_mask->ip_ver) 389 return -EOPNOTSUPP; 390 391 if (uip_mask->ip4src) { 392 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_SRC); 393 *(__be32 *)(key + off) = uip_value->ip4src; 394 *(__be32 *)(mask + off) = uip_mask->ip4src; 395 *fields |= DPAA2_ETH_DIST_IPSRC; 396 } 397 398 if (uip_mask->ip4dst) { 399 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_DST); 400 *(__be32 *)(key + off) = uip_value->ip4dst; 401 *(__be32 *)(mask + off) = uip_mask->ip4dst; 402 *fields |= DPAA2_ETH_DIST_IPDST; 403 } 404 405 if (uip_mask->proto) { 406 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_PROTO); 407 *(u8 *)(key + off) = uip_value->proto; 408 *(u8 *)(mask + off) = uip_mask->proto; 409 *fields |= DPAA2_ETH_DIST_IPPROTO; 410 } 411 412 if (uip_mask->l4_4_bytes) { 413 tmp_value = be32_to_cpu(uip_value->l4_4_bytes); 414 tmp_mask = be32_to_cpu(uip_mask->l4_4_bytes); 415 416 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_SRC); 417 *(__be16 *)(key + off) = htons(tmp_value >> 16); 418 *(__be16 *)(mask + off) = htons(tmp_mask >> 16); 419 *fields |= DPAA2_ETH_DIST_L4SRC; 420 421 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_DST); 422 *(__be16 *)(key + off) = htons(tmp_value & 0xFFFF); 423 *(__be16 *)(mask + off) = htons(tmp_mask & 0xFFFF); 424 *fields |= DPAA2_ETH_DIST_L4DST; 425 } 426 427 /* Only apply the rule for IPv4 frames */ 428 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE); 429 *(__be16 *)(key + off) = htons(ETH_P_IP); 430 *(__be16 *)(mask + off) = htons(0xFFFF); 431 *fields |= DPAA2_ETH_DIST_ETHTYPE; 432 433 return 0; 434 } 435 436 static int dpaa2_eth_prep_l4_rule(struct ethtool_tcpip4_spec *l4_value, 437 struct ethtool_tcpip4_spec *l4_mask, 438 void *key, void *mask, u8 l4_proto, u64 *fields) 439 { 440 int off; 441 442 if (l4_mask->tos) 443 return -EOPNOTSUPP; 444 445 if (l4_mask->ip4src) { 446 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_SRC); 447 *(__be32 *)(key + off) = l4_value->ip4src; 448 *(__be32 *)(mask + off) = l4_mask->ip4src; 449 *fields |= DPAA2_ETH_DIST_IPSRC; 450 } 451 452 if (l4_mask->ip4dst) { 453 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_DST); 454 *(__be32 *)(key + off) = l4_value->ip4dst; 455 *(__be32 *)(mask + off) = l4_mask->ip4dst; 456 *fields |= DPAA2_ETH_DIST_IPDST; 457 } 458 459 if (l4_mask->psrc) { 460 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_SRC); 461 *(__be16 *)(key + off) = l4_value->psrc; 462 *(__be16 *)(mask + off) = l4_mask->psrc; 463 *fields |= DPAA2_ETH_DIST_L4SRC; 464 } 465 466 if (l4_mask->pdst) { 467 off = dpaa2_eth_cls_fld_off(NET_PROT_UDP, NH_FLD_UDP_PORT_DST); 468 *(__be16 *)(key + off) = l4_value->pdst; 469 *(__be16 *)(mask + off) = l4_mask->pdst; 470 *fields |= DPAA2_ETH_DIST_L4DST; 471 } 472 473 /* Only apply the rule for IPv4 frames with the specified L4 proto */ 474 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_TYPE); 475 *(__be16 *)(key + off) = htons(ETH_P_IP); 476 *(__be16 *)(mask + off) = htons(0xFFFF); 477 *fields |= DPAA2_ETH_DIST_ETHTYPE; 478 479 off = dpaa2_eth_cls_fld_off(NET_PROT_IP, NH_FLD_IP_PROTO); 480 *(u8 *)(key + off) = l4_proto; 481 *(u8 *)(mask + off) = 0xFF; 482 *fields |= DPAA2_ETH_DIST_IPPROTO; 483 484 return 0; 485 } 486 487 static int dpaa2_eth_prep_ext_rule(struct ethtool_flow_ext *ext_value, 488 struct ethtool_flow_ext *ext_mask, 489 void *key, void *mask, u64 *fields) 490 { 491 int off; 492 493 if (ext_mask->vlan_etype) 494 return -EOPNOTSUPP; 495 496 if (ext_mask->vlan_tci) { 497 off = dpaa2_eth_cls_fld_off(NET_PROT_VLAN, NH_FLD_VLAN_TCI); 498 *(__be16 *)(key + off) = ext_value->vlan_tci; 499 *(__be16 *)(mask + off) = ext_mask->vlan_tci; 500 *fields |= DPAA2_ETH_DIST_VLAN; 501 } 502 503 return 0; 504 } 505 506 static int dpaa2_eth_prep_mac_ext_rule(struct ethtool_flow_ext *ext_value, 507 struct ethtool_flow_ext *ext_mask, 508 void *key, void *mask, u64 *fields) 509 { 510 int off; 511 512 if (!is_zero_ether_addr(ext_mask->h_dest)) { 513 off = dpaa2_eth_cls_fld_off(NET_PROT_ETH, NH_FLD_ETH_DA); 514 ether_addr_copy(key + off, ext_value->h_dest); 515 ether_addr_copy(mask + off, ext_mask->h_dest); 516 *fields |= DPAA2_ETH_DIST_ETHDST; 517 } 518 519 return 0; 520 } 521 522 static int dpaa2_eth_prep_cls_rule(struct ethtool_rx_flow_spec *fs, void *key, 523 void *mask, u64 *fields) 524 { 525 int err; 526 527 switch (fs->flow_type & 0xFF) { 528 case ETHER_FLOW: 529 err = dpaa2_eth_prep_eth_rule(&fs->h_u.ether_spec, &fs->m_u.ether_spec, 530 key, mask, fields); 531 break; 532 case IP_USER_FLOW: 533 err = dpaa2_eth_prep_uip_rule(&fs->h_u.usr_ip4_spec, 534 &fs->m_u.usr_ip4_spec, key, mask, fields); 535 break; 536 case TCP_V4_FLOW: 537 err = dpaa2_eth_prep_l4_rule(&fs->h_u.tcp_ip4_spec, &fs->m_u.tcp_ip4_spec, 538 key, mask, IPPROTO_TCP, fields); 539 break; 540 case UDP_V4_FLOW: 541 err = dpaa2_eth_prep_l4_rule(&fs->h_u.udp_ip4_spec, &fs->m_u.udp_ip4_spec, 542 key, mask, IPPROTO_UDP, fields); 543 break; 544 case SCTP_V4_FLOW: 545 err = dpaa2_eth_prep_l4_rule(&fs->h_u.sctp_ip4_spec, 546 &fs->m_u.sctp_ip4_spec, key, mask, 547 IPPROTO_SCTP, fields); 548 break; 549 default: 550 return -EOPNOTSUPP; 551 } 552 553 if (err) 554 return err; 555 556 if (fs->flow_type & FLOW_EXT) { 557 err = dpaa2_eth_prep_ext_rule(&fs->h_ext, &fs->m_ext, key, mask, fields); 558 if (err) 559 return err; 560 } 561 562 if (fs->flow_type & FLOW_MAC_EXT) { 563 err = dpaa2_eth_prep_mac_ext_rule(&fs->h_ext, &fs->m_ext, key, 564 mask, fields); 565 if (err) 566 return err; 567 } 568 569 return 0; 570 } 571 572 static int dpaa2_eth_do_cls_rule(struct net_device *net_dev, 573 struct ethtool_rx_flow_spec *fs, 574 bool add) 575 { 576 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 577 struct device *dev = net_dev->dev.parent; 578 struct dpni_rule_cfg rule_cfg = { 0 }; 579 struct dpni_fs_action_cfg fs_act = { 0 }; 580 dma_addr_t key_iova; 581 u64 fields = 0; 582 void *key_buf; 583 int i, err; 584 585 if (fs->ring_cookie != RX_CLS_FLOW_DISC && 586 fs->ring_cookie >= dpaa2_eth_queue_count(priv)) 587 return -EINVAL; 588 589 rule_cfg.key_size = dpaa2_eth_cls_key_size(DPAA2_ETH_DIST_ALL); 590 591 /* allocate twice the key size, for the actual key and for mask */ 592 key_buf = kzalloc(rule_cfg.key_size * 2, GFP_KERNEL); 593 if (!key_buf) 594 return -ENOMEM; 595 596 /* Fill the key and mask memory areas */ 597 err = dpaa2_eth_prep_cls_rule(fs, key_buf, key_buf + rule_cfg.key_size, &fields); 598 if (err) 599 goto free_mem; 600 601 if (!dpaa2_eth_fs_mask_enabled(priv)) { 602 /* Masking allows us to configure a maximal key during init and 603 * use it for all flow steering rules. Without it, we include 604 * in the key only the fields actually used, so we need to 605 * extract the others from the final key buffer. 606 * 607 * Program the FS key if needed, or return error if previously 608 * set key can't be used for the current rule. User needs to 609 * delete existing rules in this case to allow for the new one. 610 */ 611 if (!priv->rx_cls_fields) { 612 err = dpaa2_eth_set_cls(net_dev, fields); 613 if (err) 614 goto free_mem; 615 616 priv->rx_cls_fields = fields; 617 } else if (priv->rx_cls_fields != fields) { 618 netdev_err(net_dev, "No support for multiple FS keys, need to delete existing rules\n"); 619 err = -EOPNOTSUPP; 620 goto free_mem; 621 } 622 623 dpaa2_eth_cls_trim_rule(key_buf, fields); 624 rule_cfg.key_size = dpaa2_eth_cls_key_size(fields); 625 } 626 627 key_iova = dma_map_single(dev, key_buf, rule_cfg.key_size * 2, 628 DMA_TO_DEVICE); 629 if (dma_mapping_error(dev, key_iova)) { 630 err = -ENOMEM; 631 goto free_mem; 632 } 633 634 rule_cfg.key_iova = key_iova; 635 if (dpaa2_eth_fs_mask_enabled(priv)) 636 rule_cfg.mask_iova = key_iova + rule_cfg.key_size; 637 638 if (add) { 639 if (fs->ring_cookie == RX_CLS_FLOW_DISC) 640 fs_act.options |= DPNI_FS_OPT_DISCARD; 641 else 642 fs_act.flow_id = fs->ring_cookie; 643 } 644 for (i = 0; i < dpaa2_eth_tc_count(priv); i++) { 645 if (add) 646 err = dpni_add_fs_entry(priv->mc_io, 0, priv->mc_token, 647 i, fs->location, &rule_cfg, 648 &fs_act); 649 else 650 err = dpni_remove_fs_entry(priv->mc_io, 0, 651 priv->mc_token, i, 652 &rule_cfg); 653 if (err || priv->dpni_attrs.options & DPNI_OPT_SHARED_FS) 654 break; 655 } 656 657 dma_unmap_single(dev, key_iova, rule_cfg.key_size * 2, DMA_TO_DEVICE); 658 659 free_mem: 660 kfree(key_buf); 661 662 return err; 663 } 664 665 static int dpaa2_eth_num_cls_rules(struct dpaa2_eth_priv *priv) 666 { 667 int i, rules = 0; 668 669 for (i = 0; i < dpaa2_eth_fs_count(priv); i++) 670 if (priv->cls_rules[i].in_use) 671 rules++; 672 673 return rules; 674 } 675 676 static int dpaa2_eth_update_cls_rule(struct net_device *net_dev, 677 struct ethtool_rx_flow_spec *new_fs, 678 unsigned int location) 679 { 680 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 681 struct dpaa2_eth_cls_rule *rule; 682 int err = -EINVAL; 683 684 if (!priv->rx_cls_enabled) 685 return -EOPNOTSUPP; 686 687 if (location >= dpaa2_eth_fs_count(priv)) 688 return -EINVAL; 689 690 rule = &priv->cls_rules[location]; 691 692 /* If a rule is present at the specified location, delete it. */ 693 if (rule->in_use) { 694 err = dpaa2_eth_do_cls_rule(net_dev, &rule->fs, false); 695 if (err) 696 return err; 697 698 rule->in_use = 0; 699 700 if (!dpaa2_eth_fs_mask_enabled(priv) && 701 !dpaa2_eth_num_cls_rules(priv)) 702 priv->rx_cls_fields = 0; 703 } 704 705 /* If no new entry to add, return here */ 706 if (!new_fs) 707 return err; 708 709 err = dpaa2_eth_do_cls_rule(net_dev, new_fs, true); 710 if (err) 711 return err; 712 713 rule->in_use = 1; 714 rule->fs = *new_fs; 715 716 return 0; 717 } 718 719 static int dpaa2_eth_get_rxnfc(struct net_device *net_dev, 720 struct ethtool_rxnfc *rxnfc, u32 *rule_locs) 721 { 722 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 723 int max_rules = dpaa2_eth_fs_count(priv); 724 int i, j = 0; 725 726 switch (rxnfc->cmd) { 727 case ETHTOOL_GRXFH: 728 /* we purposely ignore cmd->flow_type for now, because the 729 * classifier only supports a single set of fields for all 730 * protocols 731 */ 732 rxnfc->data = priv->rx_hash_fields; 733 break; 734 case ETHTOOL_GRXRINGS: 735 rxnfc->data = dpaa2_eth_queue_count(priv); 736 break; 737 case ETHTOOL_GRXCLSRLCNT: 738 rxnfc->rule_cnt = 0; 739 rxnfc->rule_cnt = dpaa2_eth_num_cls_rules(priv); 740 rxnfc->data = max_rules; 741 break; 742 case ETHTOOL_GRXCLSRULE: 743 if (rxnfc->fs.location >= max_rules) 744 return -EINVAL; 745 rxnfc->fs.location = array_index_nospec(rxnfc->fs.location, 746 max_rules); 747 if (!priv->cls_rules[rxnfc->fs.location].in_use) 748 return -EINVAL; 749 rxnfc->fs = priv->cls_rules[rxnfc->fs.location].fs; 750 break; 751 case ETHTOOL_GRXCLSRLALL: 752 for (i = 0; i < max_rules; i++) { 753 if (!priv->cls_rules[i].in_use) 754 continue; 755 if (j == rxnfc->rule_cnt) 756 return -EMSGSIZE; 757 rule_locs[j++] = i; 758 } 759 rxnfc->rule_cnt = j; 760 rxnfc->data = max_rules; 761 break; 762 default: 763 return -EOPNOTSUPP; 764 } 765 766 return 0; 767 } 768 769 static int dpaa2_eth_set_rxnfc(struct net_device *net_dev, 770 struct ethtool_rxnfc *rxnfc) 771 { 772 int err = 0; 773 774 switch (rxnfc->cmd) { 775 case ETHTOOL_SRXFH: 776 if ((rxnfc->data & DPAA2_RXH_SUPPORTED) != rxnfc->data) 777 return -EOPNOTSUPP; 778 err = dpaa2_eth_set_hash(net_dev, rxnfc->data); 779 break; 780 case ETHTOOL_SRXCLSRLINS: 781 err = dpaa2_eth_update_cls_rule(net_dev, &rxnfc->fs, rxnfc->fs.location); 782 break; 783 case ETHTOOL_SRXCLSRLDEL: 784 err = dpaa2_eth_update_cls_rule(net_dev, NULL, rxnfc->fs.location); 785 break; 786 default: 787 err = -EOPNOTSUPP; 788 } 789 790 return err; 791 } 792 793 int dpaa2_phc_index = -1; 794 EXPORT_SYMBOL(dpaa2_phc_index); 795 796 static int dpaa2_eth_get_ts_info(struct net_device *dev, 797 struct kernel_ethtool_ts_info *info) 798 { 799 if (!dpaa2_ptp) 800 return ethtool_op_get_ts_info(dev, info); 801 802 info->so_timestamping = SOF_TIMESTAMPING_TX_HARDWARE | 803 SOF_TIMESTAMPING_RX_HARDWARE | 804 SOF_TIMESTAMPING_RAW_HARDWARE; 805 806 info->phc_index = dpaa2_phc_index; 807 808 info->tx_types = (1 << HWTSTAMP_TX_OFF) | 809 (1 << HWTSTAMP_TX_ON) | 810 (1 << HWTSTAMP_TX_ONESTEP_SYNC); 811 812 info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) | 813 (1 << HWTSTAMP_FILTER_ALL); 814 return 0; 815 } 816 817 static int dpaa2_eth_get_tunable(struct net_device *net_dev, 818 const struct ethtool_tunable *tuna, 819 void *data) 820 { 821 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 822 int err = 0; 823 824 switch (tuna->id) { 825 case ETHTOOL_RX_COPYBREAK: 826 *(u32 *)data = priv->rx_copybreak; 827 break; 828 default: 829 err = -EOPNOTSUPP; 830 break; 831 } 832 833 return err; 834 } 835 836 static int dpaa2_eth_set_tunable(struct net_device *net_dev, 837 const struct ethtool_tunable *tuna, 838 const void *data) 839 { 840 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 841 int err = 0; 842 843 switch (tuna->id) { 844 case ETHTOOL_RX_COPYBREAK: 845 priv->rx_copybreak = *(u32 *)data; 846 break; 847 default: 848 err = -EOPNOTSUPP; 849 break; 850 } 851 852 return err; 853 } 854 855 static int dpaa2_eth_get_coalesce(struct net_device *dev, 856 struct ethtool_coalesce *ic, 857 struct kernel_ethtool_coalesce *kernel_coal, 858 struct netlink_ext_ack *extack) 859 { 860 struct dpaa2_eth_priv *priv = netdev_priv(dev); 861 struct dpaa2_io *dpio = priv->channel[0]->dpio; 862 863 dpaa2_io_get_irq_coalescing(dpio, &ic->rx_coalesce_usecs); 864 ic->use_adaptive_rx_coalesce = dpaa2_io_get_adaptive_coalescing(dpio); 865 866 return 0; 867 } 868 869 static int dpaa2_eth_set_coalesce(struct net_device *dev, 870 struct ethtool_coalesce *ic, 871 struct kernel_ethtool_coalesce *kernel_coal, 872 struct netlink_ext_ack *extack) 873 { 874 struct dpaa2_eth_priv *priv = netdev_priv(dev); 875 struct dpaa2_io *dpio; 876 int prev_adaptive; 877 u32 prev_rx_usecs; 878 int i, j, err; 879 880 /* Keep track of the previous value, just in case we fail */ 881 dpio = priv->channel[0]->dpio; 882 dpaa2_io_get_irq_coalescing(dpio, &prev_rx_usecs); 883 prev_adaptive = dpaa2_io_get_adaptive_coalescing(dpio); 884 885 /* Setup new value for rx coalescing */ 886 for (i = 0; i < priv->num_channels; i++) { 887 dpio = priv->channel[i]->dpio; 888 889 dpaa2_io_set_adaptive_coalescing(dpio, 890 ic->use_adaptive_rx_coalesce); 891 err = dpaa2_io_set_irq_coalescing(dpio, ic->rx_coalesce_usecs); 892 if (err) 893 goto restore_rx_usecs; 894 } 895 896 return 0; 897 898 restore_rx_usecs: 899 for (j = 0; j < i; j++) { 900 dpio = priv->channel[j]->dpio; 901 902 dpaa2_io_set_irq_coalescing(dpio, prev_rx_usecs); 903 dpaa2_io_set_adaptive_coalescing(dpio, prev_adaptive); 904 } 905 906 return err; 907 } 908 909 static void dpaa2_eth_get_channels(struct net_device *net_dev, 910 struct ethtool_channels *channels) 911 { 912 struct dpaa2_eth_priv *priv = netdev_priv(net_dev); 913 int queue_count = dpaa2_eth_queue_count(priv); 914 915 channels->max_rx = queue_count; 916 channels->max_tx = queue_count; 917 channels->rx_count = queue_count; 918 channels->tx_count = queue_count; 919 920 /* Tx confirmation and Rx error */ 921 channels->max_other = queue_count + 1; 922 channels->max_combined = channels->max_rx + 923 channels->max_tx + 924 channels->max_other; 925 /* Tx conf and Rx err */ 926 channels->other_count = queue_count + 1; 927 channels->combined_count = channels->rx_count + 928 channels->tx_count + 929 channels->other_count; 930 } 931 932 const struct ethtool_ops dpaa2_ethtool_ops = { 933 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS | 934 ETHTOOL_COALESCE_USE_ADAPTIVE_RX, 935 .get_drvinfo = dpaa2_eth_get_drvinfo, 936 .nway_reset = dpaa2_eth_nway_reset, 937 .get_link = ethtool_op_get_link, 938 .get_link_ksettings = dpaa2_eth_get_link_ksettings, 939 .set_link_ksettings = dpaa2_eth_set_link_ksettings, 940 .get_pauseparam = dpaa2_eth_get_pauseparam, 941 .set_pauseparam = dpaa2_eth_set_pauseparam, 942 .get_sset_count = dpaa2_eth_get_sset_count, 943 .get_ethtool_stats = dpaa2_eth_get_ethtool_stats, 944 .get_strings = dpaa2_eth_get_strings, 945 .get_rxnfc = dpaa2_eth_get_rxnfc, 946 .set_rxnfc = dpaa2_eth_set_rxnfc, 947 .get_ts_info = dpaa2_eth_get_ts_info, 948 .get_tunable = dpaa2_eth_get_tunable, 949 .set_tunable = dpaa2_eth_set_tunable, 950 .get_coalesce = dpaa2_eth_get_coalesce, 951 .set_coalesce = dpaa2_eth_set_coalesce, 952 .get_channels = dpaa2_eth_get_channels, 953 }; 954