1 /* 2 * Copyright (c) 2007 Mellanox Technologies. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 * 32 */ 33 34 #include <linux/kernel.h> 35 #include <linux/ethtool.h> 36 #include <linux/netdevice.h> 37 #include <linux/mlx4/driver.h> 38 39 #include "mlx4_en.h" 40 #include "en_port.h" 41 42 #define EN_ETHTOOL_QP_ATTACH (1ull << 63) 43 #define EN_ETHTOOL_SHORT_MASK cpu_to_be16(0xffff) 44 #define EN_ETHTOOL_WORD_MASK cpu_to_be32(0xffffffff) 45 46 static int mlx4_en_moderation_update(struct mlx4_en_priv *priv) 47 { 48 int i; 49 int err = 0; 50 51 for (i = 0; i < priv->tx_ring_num; i++) { 52 priv->tx_cq[i].moder_cnt = priv->tx_frames; 53 priv->tx_cq[i].moder_time = priv->tx_usecs; 54 err = mlx4_en_set_cq_moder(priv, &priv->tx_cq[i]); 55 if (err) 56 return err; 57 } 58 59 if (priv->adaptive_rx_coal) 60 return 0; 61 62 for (i = 0; i < priv->rx_ring_num; i++) { 63 priv->rx_cq[i].moder_cnt = priv->rx_frames; 64 priv->rx_cq[i].moder_time = priv->rx_usecs; 65 priv->last_moder_time[i] = MLX4_EN_AUTO_CONF; 66 err = mlx4_en_set_cq_moder(priv, &priv->rx_cq[i]); 67 if (err) 68 return err; 69 } 70 71 return err; 72 } 73 74 static void 75 mlx4_en_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *drvinfo) 76 { 77 struct mlx4_en_priv *priv = netdev_priv(dev); 78 struct mlx4_en_dev *mdev = priv->mdev; 79 80 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver)); 81 strlcpy(drvinfo->version, DRV_VERSION " (" DRV_RELDATE ")", 82 sizeof(drvinfo->version)); 83 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 84 "%d.%d.%d", 85 (u16) (mdev->dev->caps.fw_ver >> 32), 86 (u16) ((mdev->dev->caps.fw_ver >> 16) & 0xffff), 87 (u16) (mdev->dev->caps.fw_ver & 0xffff)); 88 strlcpy(drvinfo->bus_info, pci_name(mdev->dev->pdev), 89 sizeof(drvinfo->bus_info)); 90 drvinfo->n_stats = 0; 91 drvinfo->regdump_len = 0; 92 drvinfo->eedump_len = 0; 93 } 94 95 static const char main_strings[][ETH_GSTRING_LEN] = { 96 "rx_packets", "tx_packets", "rx_bytes", "tx_bytes", "rx_errors", 97 "tx_errors", "rx_dropped", "tx_dropped", "multicast", "collisions", 98 "rx_length_errors", "rx_over_errors", "rx_crc_errors", 99 "rx_frame_errors", "rx_fifo_errors", "rx_missed_errors", 100 "tx_aborted_errors", "tx_carrier_errors", "tx_fifo_errors", 101 "tx_heartbeat_errors", "tx_window_errors", 102 103 /* port statistics */ 104 "tso_packets", 105 "queue_stopped", "wake_queue", "tx_timeout", "rx_alloc_failed", 106 "rx_csum_good", "rx_csum_none", "tx_chksum_offload", 107 108 /* packet statistics */ 109 "broadcast", "rx_prio_0", "rx_prio_1", "rx_prio_2", "rx_prio_3", 110 "rx_prio_4", "rx_prio_5", "rx_prio_6", "rx_prio_7", "tx_prio_0", 111 "tx_prio_1", "tx_prio_2", "tx_prio_3", "tx_prio_4", "tx_prio_5", 112 "tx_prio_6", "tx_prio_7", 113 }; 114 #define NUM_MAIN_STATS 21 115 #define NUM_ALL_STATS (NUM_MAIN_STATS + NUM_PORT_STATS + NUM_PKT_STATS + NUM_PERF_STATS) 116 117 static const char mlx4_en_test_names[][ETH_GSTRING_LEN]= { 118 "Interrupt Test", 119 "Link Test", 120 "Speed Test", 121 "Register Test", 122 "Loopback Test", 123 }; 124 125 static u32 mlx4_en_get_msglevel(struct net_device *dev) 126 { 127 return ((struct mlx4_en_priv *) netdev_priv(dev))->msg_enable; 128 } 129 130 static void mlx4_en_set_msglevel(struct net_device *dev, u32 val) 131 { 132 ((struct mlx4_en_priv *) netdev_priv(dev))->msg_enable = val; 133 } 134 135 static void mlx4_en_get_wol(struct net_device *netdev, 136 struct ethtool_wolinfo *wol) 137 { 138 struct mlx4_en_priv *priv = netdev_priv(netdev); 139 int err = 0; 140 u64 config = 0; 141 u64 mask; 142 143 if ((priv->port < 1) || (priv->port > 2)) { 144 en_err(priv, "Failed to get WoL information\n"); 145 return; 146 } 147 148 mask = (priv->port == 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1 : 149 MLX4_DEV_CAP_FLAG_WOL_PORT2; 150 151 if (!(priv->mdev->dev->caps.flags & mask)) { 152 wol->supported = 0; 153 wol->wolopts = 0; 154 return; 155 } 156 157 err = mlx4_wol_read(priv->mdev->dev, &config, priv->port); 158 if (err) { 159 en_err(priv, "Failed to get WoL information\n"); 160 return; 161 } 162 163 if (config & MLX4_EN_WOL_MAGIC) 164 wol->supported = WAKE_MAGIC; 165 else 166 wol->supported = 0; 167 168 if (config & MLX4_EN_WOL_ENABLED) 169 wol->wolopts = WAKE_MAGIC; 170 else 171 wol->wolopts = 0; 172 } 173 174 static int mlx4_en_set_wol(struct net_device *netdev, 175 struct ethtool_wolinfo *wol) 176 { 177 struct mlx4_en_priv *priv = netdev_priv(netdev); 178 u64 config = 0; 179 int err = 0; 180 u64 mask; 181 182 if ((priv->port < 1) || (priv->port > 2)) 183 return -EOPNOTSUPP; 184 185 mask = (priv->port == 1) ? MLX4_DEV_CAP_FLAG_WOL_PORT1 : 186 MLX4_DEV_CAP_FLAG_WOL_PORT2; 187 188 if (!(priv->mdev->dev->caps.flags & mask)) 189 return -EOPNOTSUPP; 190 191 if (wol->supported & ~WAKE_MAGIC) 192 return -EINVAL; 193 194 err = mlx4_wol_read(priv->mdev->dev, &config, priv->port); 195 if (err) { 196 en_err(priv, "Failed to get WoL info, unable to modify\n"); 197 return err; 198 } 199 200 if (wol->wolopts & WAKE_MAGIC) { 201 config |= MLX4_EN_WOL_DO_MODIFY | MLX4_EN_WOL_ENABLED | 202 MLX4_EN_WOL_MAGIC; 203 } else { 204 config &= ~(MLX4_EN_WOL_ENABLED | MLX4_EN_WOL_MAGIC); 205 config |= MLX4_EN_WOL_DO_MODIFY; 206 } 207 208 err = mlx4_wol_write(priv->mdev->dev, config, priv->port); 209 if (err) 210 en_err(priv, "Failed to set WoL information\n"); 211 212 return err; 213 } 214 215 static int mlx4_en_get_sset_count(struct net_device *dev, int sset) 216 { 217 struct mlx4_en_priv *priv = netdev_priv(dev); 218 int bit_count = hweight64(priv->stats_bitmap); 219 220 switch (sset) { 221 case ETH_SS_STATS: 222 return (priv->stats_bitmap ? bit_count : NUM_ALL_STATS) + 223 (priv->tx_ring_num + priv->rx_ring_num) * 2; 224 case ETH_SS_TEST: 225 return MLX4_EN_NUM_SELF_TEST - !(priv->mdev->dev->caps.flags 226 & MLX4_DEV_CAP_FLAG_UC_LOOPBACK) * 2; 227 default: 228 return -EOPNOTSUPP; 229 } 230 } 231 232 static void mlx4_en_get_ethtool_stats(struct net_device *dev, 233 struct ethtool_stats *stats, uint64_t *data) 234 { 235 struct mlx4_en_priv *priv = netdev_priv(dev); 236 int index = 0; 237 int i, j = 0; 238 239 spin_lock_bh(&priv->stats_lock); 240 241 if (!(priv->stats_bitmap)) { 242 for (i = 0; i < NUM_MAIN_STATS; i++) 243 data[index++] = 244 ((unsigned long *) &priv->stats)[i]; 245 for (i = 0; i < NUM_PORT_STATS; i++) 246 data[index++] = 247 ((unsigned long *) &priv->port_stats)[i]; 248 for (i = 0; i < NUM_PKT_STATS; i++) 249 data[index++] = 250 ((unsigned long *) &priv->pkstats)[i]; 251 } else { 252 for (i = 0; i < NUM_MAIN_STATS; i++) { 253 if ((priv->stats_bitmap >> j) & 1) 254 data[index++] = 255 ((unsigned long *) &priv->stats)[i]; 256 j++; 257 } 258 for (i = 0; i < NUM_PORT_STATS; i++) { 259 if ((priv->stats_bitmap >> j) & 1) 260 data[index++] = 261 ((unsigned long *) &priv->port_stats)[i]; 262 j++; 263 } 264 } 265 for (i = 0; i < priv->tx_ring_num; i++) { 266 data[index++] = priv->tx_ring[i].packets; 267 data[index++] = priv->tx_ring[i].bytes; 268 } 269 for (i = 0; i < priv->rx_ring_num; i++) { 270 data[index++] = priv->rx_ring[i].packets; 271 data[index++] = priv->rx_ring[i].bytes; 272 } 273 spin_unlock_bh(&priv->stats_lock); 274 275 } 276 277 static void mlx4_en_self_test(struct net_device *dev, 278 struct ethtool_test *etest, u64 *buf) 279 { 280 mlx4_en_ex_selftest(dev, &etest->flags, buf); 281 } 282 283 static void mlx4_en_get_strings(struct net_device *dev, 284 uint32_t stringset, uint8_t *data) 285 { 286 struct mlx4_en_priv *priv = netdev_priv(dev); 287 int index = 0; 288 int i; 289 290 switch (stringset) { 291 case ETH_SS_TEST: 292 for (i = 0; i < MLX4_EN_NUM_SELF_TEST - 2; i++) 293 strcpy(data + i * ETH_GSTRING_LEN, mlx4_en_test_names[i]); 294 if (priv->mdev->dev->caps.flags & MLX4_DEV_CAP_FLAG_UC_LOOPBACK) 295 for (; i < MLX4_EN_NUM_SELF_TEST; i++) 296 strcpy(data + i * ETH_GSTRING_LEN, mlx4_en_test_names[i]); 297 break; 298 299 case ETH_SS_STATS: 300 /* Add main counters */ 301 if (!priv->stats_bitmap) { 302 for (i = 0; i < NUM_MAIN_STATS; i++) 303 strcpy(data + (index++) * ETH_GSTRING_LEN, 304 main_strings[i]); 305 for (i = 0; i < NUM_PORT_STATS; i++) 306 strcpy(data + (index++) * ETH_GSTRING_LEN, 307 main_strings[i + 308 NUM_MAIN_STATS]); 309 for (i = 0; i < NUM_PKT_STATS; i++) 310 strcpy(data + (index++) * ETH_GSTRING_LEN, 311 main_strings[i + 312 NUM_MAIN_STATS + 313 NUM_PORT_STATS]); 314 } else 315 for (i = 0; i < NUM_MAIN_STATS + NUM_PORT_STATS; i++) { 316 if ((priv->stats_bitmap >> i) & 1) { 317 strcpy(data + 318 (index++) * ETH_GSTRING_LEN, 319 main_strings[i]); 320 } 321 if (!(priv->stats_bitmap >> i)) 322 break; 323 } 324 for (i = 0; i < priv->tx_ring_num; i++) { 325 sprintf(data + (index++) * ETH_GSTRING_LEN, 326 "tx%d_packets", i); 327 sprintf(data + (index++) * ETH_GSTRING_LEN, 328 "tx%d_bytes", i); 329 } 330 for (i = 0; i < priv->rx_ring_num; i++) { 331 sprintf(data + (index++) * ETH_GSTRING_LEN, 332 "rx%d_packets", i); 333 sprintf(data + (index++) * ETH_GSTRING_LEN, 334 "rx%d_bytes", i); 335 } 336 break; 337 } 338 } 339 340 static int mlx4_en_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 341 { 342 struct mlx4_en_priv *priv = netdev_priv(dev); 343 int trans_type; 344 345 cmd->autoneg = AUTONEG_DISABLE; 346 cmd->supported = SUPPORTED_10000baseT_Full; 347 cmd->advertising = ADVERTISED_10000baseT_Full; 348 349 if (mlx4_en_QUERY_PORT(priv->mdev, priv->port)) 350 return -ENOMEM; 351 352 trans_type = priv->port_state.transciver; 353 if (netif_carrier_ok(dev)) { 354 ethtool_cmd_speed_set(cmd, priv->port_state.link_speed); 355 cmd->duplex = DUPLEX_FULL; 356 } else { 357 ethtool_cmd_speed_set(cmd, -1); 358 cmd->duplex = -1; 359 } 360 361 if (trans_type > 0 && trans_type <= 0xC) { 362 cmd->port = PORT_FIBRE; 363 cmd->transceiver = XCVR_EXTERNAL; 364 cmd->supported |= SUPPORTED_FIBRE; 365 cmd->advertising |= ADVERTISED_FIBRE; 366 } else if (trans_type == 0x80 || trans_type == 0) { 367 cmd->port = PORT_TP; 368 cmd->transceiver = XCVR_INTERNAL; 369 cmd->supported |= SUPPORTED_TP; 370 cmd->advertising |= ADVERTISED_TP; 371 } else { 372 cmd->port = -1; 373 cmd->transceiver = -1; 374 } 375 return 0; 376 } 377 378 static int mlx4_en_set_settings(struct net_device *dev, struct ethtool_cmd *cmd) 379 { 380 if ((cmd->autoneg == AUTONEG_ENABLE) || 381 (ethtool_cmd_speed(cmd) != SPEED_10000) || 382 (cmd->duplex != DUPLEX_FULL)) 383 return -EINVAL; 384 385 /* Nothing to change */ 386 return 0; 387 } 388 389 static int mlx4_en_get_coalesce(struct net_device *dev, 390 struct ethtool_coalesce *coal) 391 { 392 struct mlx4_en_priv *priv = netdev_priv(dev); 393 394 coal->tx_coalesce_usecs = priv->tx_usecs; 395 coal->tx_max_coalesced_frames = priv->tx_frames; 396 coal->rx_coalesce_usecs = priv->rx_usecs; 397 coal->rx_max_coalesced_frames = priv->rx_frames; 398 399 coal->pkt_rate_low = priv->pkt_rate_low; 400 coal->rx_coalesce_usecs_low = priv->rx_usecs_low; 401 coal->pkt_rate_high = priv->pkt_rate_high; 402 coal->rx_coalesce_usecs_high = priv->rx_usecs_high; 403 coal->rate_sample_interval = priv->sample_interval; 404 coal->use_adaptive_rx_coalesce = priv->adaptive_rx_coal; 405 return 0; 406 } 407 408 static int mlx4_en_set_coalesce(struct net_device *dev, 409 struct ethtool_coalesce *coal) 410 { 411 struct mlx4_en_priv *priv = netdev_priv(dev); 412 413 priv->rx_frames = (coal->rx_max_coalesced_frames == 414 MLX4_EN_AUTO_CONF) ? 415 MLX4_EN_RX_COAL_TARGET : 416 coal->rx_max_coalesced_frames; 417 priv->rx_usecs = (coal->rx_coalesce_usecs == 418 MLX4_EN_AUTO_CONF) ? 419 MLX4_EN_RX_COAL_TIME : 420 coal->rx_coalesce_usecs; 421 422 /* Setting TX coalescing parameters */ 423 if (coal->tx_coalesce_usecs != priv->tx_usecs || 424 coal->tx_max_coalesced_frames != priv->tx_frames) { 425 priv->tx_usecs = coal->tx_coalesce_usecs; 426 priv->tx_frames = coal->tx_max_coalesced_frames; 427 } 428 429 /* Set adaptive coalescing params */ 430 priv->pkt_rate_low = coal->pkt_rate_low; 431 priv->rx_usecs_low = coal->rx_coalesce_usecs_low; 432 priv->pkt_rate_high = coal->pkt_rate_high; 433 priv->rx_usecs_high = coal->rx_coalesce_usecs_high; 434 priv->sample_interval = coal->rate_sample_interval; 435 priv->adaptive_rx_coal = coal->use_adaptive_rx_coalesce; 436 437 return mlx4_en_moderation_update(priv); 438 } 439 440 static int mlx4_en_set_pauseparam(struct net_device *dev, 441 struct ethtool_pauseparam *pause) 442 { 443 struct mlx4_en_priv *priv = netdev_priv(dev); 444 struct mlx4_en_dev *mdev = priv->mdev; 445 int err; 446 447 priv->prof->tx_pause = pause->tx_pause != 0; 448 priv->prof->rx_pause = pause->rx_pause != 0; 449 err = mlx4_SET_PORT_general(mdev->dev, priv->port, 450 priv->rx_skb_size + ETH_FCS_LEN, 451 priv->prof->tx_pause, 452 priv->prof->tx_ppp, 453 priv->prof->rx_pause, 454 priv->prof->rx_ppp); 455 if (err) 456 en_err(priv, "Failed setting pause params\n"); 457 458 return err; 459 } 460 461 static void mlx4_en_get_pauseparam(struct net_device *dev, 462 struct ethtool_pauseparam *pause) 463 { 464 struct mlx4_en_priv *priv = netdev_priv(dev); 465 466 pause->tx_pause = priv->prof->tx_pause; 467 pause->rx_pause = priv->prof->rx_pause; 468 } 469 470 static int mlx4_en_set_ringparam(struct net_device *dev, 471 struct ethtool_ringparam *param) 472 { 473 struct mlx4_en_priv *priv = netdev_priv(dev); 474 struct mlx4_en_dev *mdev = priv->mdev; 475 u32 rx_size, tx_size; 476 int port_up = 0; 477 int err = 0; 478 479 if (param->rx_jumbo_pending || param->rx_mini_pending) 480 return -EINVAL; 481 482 rx_size = roundup_pow_of_two(param->rx_pending); 483 rx_size = max_t(u32, rx_size, MLX4_EN_MIN_RX_SIZE); 484 rx_size = min_t(u32, rx_size, MLX4_EN_MAX_RX_SIZE); 485 tx_size = roundup_pow_of_two(param->tx_pending); 486 tx_size = max_t(u32, tx_size, MLX4_EN_MIN_TX_SIZE); 487 tx_size = min_t(u32, tx_size, MLX4_EN_MAX_TX_SIZE); 488 489 if (rx_size == (priv->port_up ? priv->rx_ring[0].actual_size : 490 priv->rx_ring[0].size) && 491 tx_size == priv->tx_ring[0].size) 492 return 0; 493 494 mutex_lock(&mdev->state_lock); 495 if (priv->port_up) { 496 port_up = 1; 497 mlx4_en_stop_port(dev); 498 } 499 500 mlx4_en_free_resources(priv); 501 502 priv->prof->tx_ring_size = tx_size; 503 priv->prof->rx_ring_size = rx_size; 504 505 err = mlx4_en_alloc_resources(priv); 506 if (err) { 507 en_err(priv, "Failed reallocating port resources\n"); 508 goto out; 509 } 510 if (port_up) { 511 err = mlx4_en_start_port(dev); 512 if (err) 513 en_err(priv, "Failed starting port\n"); 514 } 515 516 err = mlx4_en_moderation_update(priv); 517 518 out: 519 mutex_unlock(&mdev->state_lock); 520 return err; 521 } 522 523 static void mlx4_en_get_ringparam(struct net_device *dev, 524 struct ethtool_ringparam *param) 525 { 526 struct mlx4_en_priv *priv = netdev_priv(dev); 527 528 memset(param, 0, sizeof(*param)); 529 param->rx_max_pending = MLX4_EN_MAX_RX_SIZE; 530 param->tx_max_pending = MLX4_EN_MAX_TX_SIZE; 531 param->rx_pending = priv->port_up ? 532 priv->rx_ring[0].actual_size : priv->rx_ring[0].size; 533 param->tx_pending = priv->tx_ring[0].size; 534 } 535 536 static u32 mlx4_en_get_rxfh_indir_size(struct net_device *dev) 537 { 538 struct mlx4_en_priv *priv = netdev_priv(dev); 539 540 return priv->rx_ring_num; 541 } 542 543 static int mlx4_en_get_rxfh_indir(struct net_device *dev, u32 *ring_index) 544 { 545 struct mlx4_en_priv *priv = netdev_priv(dev); 546 struct mlx4_en_rss_map *rss_map = &priv->rss_map; 547 int rss_rings; 548 size_t n = priv->rx_ring_num; 549 int err = 0; 550 551 rss_rings = priv->prof->rss_rings ?: priv->rx_ring_num; 552 553 while (n--) { 554 ring_index[n] = rss_map->qps[n % rss_rings].qpn - 555 rss_map->base_qpn; 556 } 557 558 return err; 559 } 560 561 static int mlx4_en_set_rxfh_indir(struct net_device *dev, 562 const u32 *ring_index) 563 { 564 struct mlx4_en_priv *priv = netdev_priv(dev); 565 struct mlx4_en_dev *mdev = priv->mdev; 566 int port_up = 0; 567 int err = 0; 568 int i; 569 int rss_rings = 0; 570 571 /* Calculate RSS table size and make sure flows are spread evenly 572 * between rings 573 */ 574 for (i = 0; i < priv->rx_ring_num; i++) { 575 if (i > 0 && !ring_index[i] && !rss_rings) 576 rss_rings = i; 577 578 if (ring_index[i] != (i % (rss_rings ?: priv->rx_ring_num))) 579 return -EINVAL; 580 } 581 582 if (!rss_rings) 583 rss_rings = priv->rx_ring_num; 584 585 /* RSS table size must be an order of 2 */ 586 if (!is_power_of_2(rss_rings)) 587 return -EINVAL; 588 589 mutex_lock(&mdev->state_lock); 590 if (priv->port_up) { 591 port_up = 1; 592 mlx4_en_stop_port(dev); 593 } 594 595 priv->prof->rss_rings = rss_rings; 596 597 if (port_up) { 598 err = mlx4_en_start_port(dev); 599 if (err) 600 en_err(priv, "Failed starting port\n"); 601 } 602 603 mutex_unlock(&mdev->state_lock); 604 return err; 605 } 606 607 #define all_zeros_or_all_ones(field) \ 608 ((field) == 0 || (field) == (__force typeof(field))-1) 609 610 static int mlx4_en_validate_flow(struct net_device *dev, 611 struct ethtool_rxnfc *cmd) 612 { 613 struct ethtool_usrip4_spec *l3_mask; 614 struct ethtool_tcpip4_spec *l4_mask; 615 struct ethhdr *eth_mask; 616 617 if (cmd->fs.location >= MAX_NUM_OF_FS_RULES) 618 return -EINVAL; 619 620 if (cmd->fs.flow_type & FLOW_MAC_EXT) { 621 /* dest mac mask must be ff:ff:ff:ff:ff:ff */ 622 if (!is_broadcast_ether_addr(cmd->fs.m_ext.h_dest)) 623 return -EINVAL; 624 } 625 626 switch (cmd->fs.flow_type & ~(FLOW_EXT | FLOW_MAC_EXT)) { 627 case TCP_V4_FLOW: 628 case UDP_V4_FLOW: 629 if (cmd->fs.m_u.tcp_ip4_spec.tos) 630 return -EINVAL; 631 l4_mask = &cmd->fs.m_u.tcp_ip4_spec; 632 /* don't allow mask which isn't all 0 or 1 */ 633 if (!all_zeros_or_all_ones(l4_mask->ip4src) || 634 !all_zeros_or_all_ones(l4_mask->ip4dst) || 635 !all_zeros_or_all_ones(l4_mask->psrc) || 636 !all_zeros_or_all_ones(l4_mask->pdst)) 637 return -EINVAL; 638 break; 639 case IP_USER_FLOW: 640 l3_mask = &cmd->fs.m_u.usr_ip4_spec; 641 if (l3_mask->l4_4_bytes || l3_mask->tos || l3_mask->proto || 642 cmd->fs.h_u.usr_ip4_spec.ip_ver != ETH_RX_NFC_IP4 || 643 (!l3_mask->ip4src && !l3_mask->ip4dst) || 644 !all_zeros_or_all_ones(l3_mask->ip4src) || 645 !all_zeros_or_all_ones(l3_mask->ip4dst)) 646 return -EINVAL; 647 break; 648 case ETHER_FLOW: 649 eth_mask = &cmd->fs.m_u.ether_spec; 650 /* source mac mask must not be set */ 651 if (!is_zero_ether_addr(eth_mask->h_source)) 652 return -EINVAL; 653 654 /* dest mac mask must be ff:ff:ff:ff:ff:ff */ 655 if (!is_broadcast_ether_addr(eth_mask->h_dest)) 656 return -EINVAL; 657 658 if (!all_zeros_or_all_ones(eth_mask->h_proto)) 659 return -EINVAL; 660 break; 661 default: 662 return -EINVAL; 663 } 664 665 if ((cmd->fs.flow_type & FLOW_EXT)) { 666 if (cmd->fs.m_ext.vlan_etype || 667 !(cmd->fs.m_ext.vlan_tci == 0 || 668 cmd->fs.m_ext.vlan_tci == cpu_to_be16(0xfff))) 669 return -EINVAL; 670 } 671 672 return 0; 673 } 674 675 static int add_ip_rule(struct mlx4_en_priv *priv, 676 struct ethtool_rxnfc *cmd, 677 struct list_head *list_h) 678 { 679 struct mlx4_spec_list *spec_l3; 680 struct ethtool_usrip4_spec *l3_mask = &cmd->fs.m_u.usr_ip4_spec; 681 682 spec_l3 = kzalloc(sizeof *spec_l3, GFP_KERNEL); 683 if (!spec_l3) { 684 en_err(priv, "Fail to alloc ethtool rule.\n"); 685 return -ENOMEM; 686 } 687 688 spec_l3->id = MLX4_NET_TRANS_RULE_ID_IPV4; 689 spec_l3->ipv4.src_ip = cmd->fs.h_u.usr_ip4_spec.ip4src; 690 if (l3_mask->ip4src) 691 spec_l3->ipv4.src_ip_msk = EN_ETHTOOL_WORD_MASK; 692 spec_l3->ipv4.dst_ip = cmd->fs.h_u.usr_ip4_spec.ip4dst; 693 if (l3_mask->ip4dst) 694 spec_l3->ipv4.dst_ip_msk = EN_ETHTOOL_WORD_MASK; 695 list_add_tail(&spec_l3->list, list_h); 696 697 return 0; 698 } 699 700 static int add_tcp_udp_rule(struct mlx4_en_priv *priv, 701 struct ethtool_rxnfc *cmd, 702 struct list_head *list_h, int proto) 703 { 704 struct mlx4_spec_list *spec_l3; 705 struct mlx4_spec_list *spec_l4; 706 struct ethtool_tcpip4_spec *l4_mask = &cmd->fs.m_u.tcp_ip4_spec; 707 708 spec_l3 = kzalloc(sizeof *spec_l3, GFP_KERNEL); 709 spec_l4 = kzalloc(sizeof *spec_l4, GFP_KERNEL); 710 if (!spec_l4 || !spec_l3) { 711 en_err(priv, "Fail to alloc ethtool rule.\n"); 712 kfree(spec_l3); 713 kfree(spec_l4); 714 return -ENOMEM; 715 } 716 717 spec_l3->id = MLX4_NET_TRANS_RULE_ID_IPV4; 718 719 if (proto == TCP_V4_FLOW) { 720 spec_l4->id = MLX4_NET_TRANS_RULE_ID_TCP; 721 spec_l3->ipv4.src_ip = cmd->fs.h_u.tcp_ip4_spec.ip4src; 722 spec_l3->ipv4.dst_ip = cmd->fs.h_u.tcp_ip4_spec.ip4dst; 723 spec_l4->tcp_udp.src_port = cmd->fs.h_u.tcp_ip4_spec.psrc; 724 spec_l4->tcp_udp.dst_port = cmd->fs.h_u.tcp_ip4_spec.pdst; 725 } else { 726 spec_l4->id = MLX4_NET_TRANS_RULE_ID_UDP; 727 spec_l3->ipv4.src_ip = cmd->fs.h_u.udp_ip4_spec.ip4src; 728 spec_l3->ipv4.dst_ip = cmd->fs.h_u.udp_ip4_spec.ip4dst; 729 spec_l4->tcp_udp.src_port = cmd->fs.h_u.udp_ip4_spec.psrc; 730 spec_l4->tcp_udp.dst_port = cmd->fs.h_u.udp_ip4_spec.pdst; 731 } 732 733 if (l4_mask->ip4src) 734 spec_l3->ipv4.src_ip_msk = EN_ETHTOOL_WORD_MASK; 735 if (l4_mask->ip4dst) 736 spec_l3->ipv4.dst_ip_msk = EN_ETHTOOL_WORD_MASK; 737 738 if (l4_mask->psrc) 739 spec_l4->tcp_udp.src_port_msk = EN_ETHTOOL_SHORT_MASK; 740 if (l4_mask->pdst) 741 spec_l4->tcp_udp.dst_port_msk = EN_ETHTOOL_SHORT_MASK; 742 743 list_add_tail(&spec_l3->list, list_h); 744 list_add_tail(&spec_l4->list, list_h); 745 746 return 0; 747 } 748 749 static int mlx4_en_ethtool_to_net_trans_rule(struct net_device *dev, 750 struct ethtool_rxnfc *cmd, 751 struct list_head *rule_list_h) 752 { 753 int err; 754 __be64 be_mac; 755 struct ethhdr *eth_spec; 756 struct mlx4_en_priv *priv = netdev_priv(dev); 757 struct mlx4_spec_list *spec_l2; 758 __be64 mac_msk = cpu_to_be64(MLX4_MAC_MASK << 16); 759 760 err = mlx4_en_validate_flow(dev, cmd); 761 if (err) 762 return err; 763 764 spec_l2 = kzalloc(sizeof *spec_l2, GFP_KERNEL); 765 if (!spec_l2) 766 return -ENOMEM; 767 768 if (cmd->fs.flow_type & FLOW_MAC_EXT) { 769 memcpy(&be_mac, cmd->fs.h_ext.h_dest, ETH_ALEN); 770 } else { 771 u64 mac = priv->mac & MLX4_MAC_MASK; 772 be_mac = cpu_to_be64(mac << 16); 773 } 774 775 spec_l2->id = MLX4_NET_TRANS_RULE_ID_ETH; 776 memcpy(spec_l2->eth.dst_mac_msk, &mac_msk, ETH_ALEN); 777 if ((cmd->fs.flow_type & ~(FLOW_EXT | FLOW_MAC_EXT)) != ETHER_FLOW) 778 memcpy(spec_l2->eth.dst_mac, &be_mac, ETH_ALEN); 779 780 if ((cmd->fs.flow_type & FLOW_EXT) && cmd->fs.m_ext.vlan_tci) { 781 spec_l2->eth.vlan_id = cmd->fs.h_ext.vlan_tci; 782 spec_l2->eth.vlan_id_msk = cpu_to_be16(0xfff); 783 } 784 785 list_add_tail(&spec_l2->list, rule_list_h); 786 787 switch (cmd->fs.flow_type & ~(FLOW_EXT | FLOW_MAC_EXT)) { 788 case ETHER_FLOW: 789 eth_spec = &cmd->fs.h_u.ether_spec; 790 memcpy(&spec_l2->eth.dst_mac, eth_spec->h_dest, ETH_ALEN); 791 spec_l2->eth.ether_type = eth_spec->h_proto; 792 if (eth_spec->h_proto) 793 spec_l2->eth.ether_type_enable = 1; 794 break; 795 case IP_USER_FLOW: 796 err = add_ip_rule(priv, cmd, rule_list_h); 797 break; 798 case TCP_V4_FLOW: 799 err = add_tcp_udp_rule(priv, cmd, rule_list_h, TCP_V4_FLOW); 800 break; 801 case UDP_V4_FLOW: 802 err = add_tcp_udp_rule(priv, cmd, rule_list_h, UDP_V4_FLOW); 803 break; 804 } 805 806 return err; 807 } 808 809 static int mlx4_en_flow_replace(struct net_device *dev, 810 struct ethtool_rxnfc *cmd) 811 { 812 int err; 813 struct mlx4_en_priv *priv = netdev_priv(dev); 814 struct ethtool_flow_id *loc_rule; 815 struct mlx4_spec_list *spec, *tmp_spec; 816 u32 qpn; 817 u64 reg_id; 818 819 struct mlx4_net_trans_rule rule = { 820 .queue_mode = MLX4_NET_TRANS_Q_FIFO, 821 .exclusive = 0, 822 .allow_loopback = 1, 823 .promisc_mode = MLX4_FS_PROMISC_NONE, 824 }; 825 826 rule.port = priv->port; 827 rule.priority = MLX4_DOMAIN_ETHTOOL | cmd->fs.location; 828 INIT_LIST_HEAD(&rule.list); 829 830 /* Allow direct QP attaches if the EN_ETHTOOL_QP_ATTACH flag is set */ 831 if (cmd->fs.ring_cookie == RX_CLS_FLOW_DISC) 832 qpn = priv->drop_qp.qpn; 833 else if (cmd->fs.ring_cookie & EN_ETHTOOL_QP_ATTACH) { 834 qpn = cmd->fs.ring_cookie & (EN_ETHTOOL_QP_ATTACH - 1); 835 } else { 836 if (cmd->fs.ring_cookie >= priv->rx_ring_num) { 837 en_warn(priv, "rxnfc: RX ring (%llu) doesn't exist.\n", 838 cmd->fs.ring_cookie); 839 return -EINVAL; 840 } 841 qpn = priv->rss_map.qps[cmd->fs.ring_cookie].qpn; 842 if (!qpn) { 843 en_warn(priv, "rxnfc: RX ring (%llu) is inactive.\n", 844 cmd->fs.ring_cookie); 845 return -EINVAL; 846 } 847 } 848 rule.qpn = qpn; 849 err = mlx4_en_ethtool_to_net_trans_rule(dev, cmd, &rule.list); 850 if (err) 851 goto out_free_list; 852 853 loc_rule = &priv->ethtool_rules[cmd->fs.location]; 854 if (loc_rule->id) { 855 err = mlx4_flow_detach(priv->mdev->dev, loc_rule->id); 856 if (err) { 857 en_err(priv, "Fail to detach network rule at location %d. registration id = %llx\n", 858 cmd->fs.location, loc_rule->id); 859 goto out_free_list; 860 } 861 loc_rule->id = 0; 862 memset(&loc_rule->flow_spec, 0, 863 sizeof(struct ethtool_rx_flow_spec)); 864 } 865 err = mlx4_flow_attach(priv->mdev->dev, &rule, ®_id); 866 if (err) { 867 en_err(priv, "Fail to attach network rule at location %d.\n", 868 cmd->fs.location); 869 goto out_free_list; 870 } 871 loc_rule->id = reg_id; 872 memcpy(&loc_rule->flow_spec, &cmd->fs, 873 sizeof(struct ethtool_rx_flow_spec)); 874 875 out_free_list: 876 list_for_each_entry_safe(spec, tmp_spec, &rule.list, list) { 877 list_del(&spec->list); 878 kfree(spec); 879 } 880 return err; 881 } 882 883 static int mlx4_en_flow_detach(struct net_device *dev, 884 struct ethtool_rxnfc *cmd) 885 { 886 int err = 0; 887 struct ethtool_flow_id *rule; 888 struct mlx4_en_priv *priv = netdev_priv(dev); 889 890 if (cmd->fs.location >= MAX_NUM_OF_FS_RULES) 891 return -EINVAL; 892 893 rule = &priv->ethtool_rules[cmd->fs.location]; 894 if (!rule->id) { 895 err = -ENOENT; 896 goto out; 897 } 898 899 err = mlx4_flow_detach(priv->mdev->dev, rule->id); 900 if (err) { 901 en_err(priv, "Fail to detach network rule at location %d. registration id = 0x%llx\n", 902 cmd->fs.location, rule->id); 903 goto out; 904 } 905 rule->id = 0; 906 memset(&rule->flow_spec, 0, sizeof(struct ethtool_rx_flow_spec)); 907 out: 908 return err; 909 910 } 911 912 static int mlx4_en_get_flow(struct net_device *dev, struct ethtool_rxnfc *cmd, 913 int loc) 914 { 915 int err = 0; 916 struct ethtool_flow_id *rule; 917 struct mlx4_en_priv *priv = netdev_priv(dev); 918 919 if (loc < 0 || loc >= MAX_NUM_OF_FS_RULES) 920 return -EINVAL; 921 922 rule = &priv->ethtool_rules[loc]; 923 if (rule->id) 924 memcpy(&cmd->fs, &rule->flow_spec, 925 sizeof(struct ethtool_rx_flow_spec)); 926 else 927 err = -ENOENT; 928 929 return err; 930 } 931 932 static int mlx4_en_get_num_flows(struct mlx4_en_priv *priv) 933 { 934 935 int i, res = 0; 936 for (i = 0; i < MAX_NUM_OF_FS_RULES; i++) { 937 if (priv->ethtool_rules[i].id) 938 res++; 939 } 940 return res; 941 942 } 943 944 static int mlx4_en_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd, 945 u32 *rule_locs) 946 { 947 struct mlx4_en_priv *priv = netdev_priv(dev); 948 struct mlx4_en_dev *mdev = priv->mdev; 949 int err = 0; 950 int i = 0, priority = 0; 951 952 if ((cmd->cmd == ETHTOOL_GRXCLSRLCNT || 953 cmd->cmd == ETHTOOL_GRXCLSRULE || 954 cmd->cmd == ETHTOOL_GRXCLSRLALL) && 955 mdev->dev->caps.steering_mode != MLX4_STEERING_MODE_DEVICE_MANAGED) 956 return -EINVAL; 957 958 switch (cmd->cmd) { 959 case ETHTOOL_GRXRINGS: 960 cmd->data = priv->rx_ring_num; 961 break; 962 case ETHTOOL_GRXCLSRLCNT: 963 cmd->rule_cnt = mlx4_en_get_num_flows(priv); 964 break; 965 case ETHTOOL_GRXCLSRULE: 966 err = mlx4_en_get_flow(dev, cmd, cmd->fs.location); 967 break; 968 case ETHTOOL_GRXCLSRLALL: 969 while ((!err || err == -ENOENT) && priority < cmd->rule_cnt) { 970 err = mlx4_en_get_flow(dev, cmd, i); 971 if (!err) 972 rule_locs[priority++] = i; 973 i++; 974 } 975 err = 0; 976 break; 977 default: 978 err = -EOPNOTSUPP; 979 break; 980 } 981 982 return err; 983 } 984 985 static int mlx4_en_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) 986 { 987 int err = 0; 988 struct mlx4_en_priv *priv = netdev_priv(dev); 989 struct mlx4_en_dev *mdev = priv->mdev; 990 991 if (mdev->dev->caps.steering_mode != MLX4_STEERING_MODE_DEVICE_MANAGED) 992 return -EINVAL; 993 994 switch (cmd->cmd) { 995 case ETHTOOL_SRXCLSRLINS: 996 err = mlx4_en_flow_replace(dev, cmd); 997 break; 998 case ETHTOOL_SRXCLSRLDEL: 999 err = mlx4_en_flow_detach(dev, cmd); 1000 break; 1001 default: 1002 en_warn(priv, "Unsupported ethtool command. (%d)\n", cmd->cmd); 1003 return -EINVAL; 1004 } 1005 1006 return err; 1007 } 1008 1009 static void mlx4_en_get_channels(struct net_device *dev, 1010 struct ethtool_channels *channel) 1011 { 1012 struct mlx4_en_priv *priv = netdev_priv(dev); 1013 1014 memset(channel, 0, sizeof(*channel)); 1015 1016 channel->max_rx = MAX_RX_RINGS; 1017 channel->max_tx = MLX4_EN_MAX_TX_RING_P_UP; 1018 1019 channel->rx_count = priv->rx_ring_num; 1020 channel->tx_count = priv->tx_ring_num / MLX4_EN_NUM_UP; 1021 } 1022 1023 static int mlx4_en_set_channels(struct net_device *dev, 1024 struct ethtool_channels *channel) 1025 { 1026 struct mlx4_en_priv *priv = netdev_priv(dev); 1027 struct mlx4_en_dev *mdev = priv->mdev; 1028 int port_up; 1029 int err = 0; 1030 1031 if (channel->other_count || channel->combined_count || 1032 channel->tx_count > MLX4_EN_MAX_TX_RING_P_UP || 1033 channel->rx_count > MAX_RX_RINGS || 1034 !channel->tx_count || !channel->rx_count) 1035 return -EINVAL; 1036 1037 mutex_lock(&mdev->state_lock); 1038 if (priv->port_up) { 1039 port_up = 1; 1040 mlx4_en_stop_port(dev); 1041 } 1042 1043 mlx4_en_free_resources(priv); 1044 1045 priv->num_tx_rings_p_up = channel->tx_count; 1046 priv->tx_ring_num = channel->tx_count * MLX4_EN_NUM_UP; 1047 priv->rx_ring_num = channel->rx_count; 1048 1049 err = mlx4_en_alloc_resources(priv); 1050 if (err) { 1051 en_err(priv, "Failed reallocating port resources\n"); 1052 goto out; 1053 } 1054 1055 netif_set_real_num_tx_queues(dev, priv->tx_ring_num); 1056 netif_set_real_num_rx_queues(dev, priv->rx_ring_num); 1057 1058 mlx4_en_setup_tc(dev, MLX4_EN_NUM_UP); 1059 1060 en_warn(priv, "Using %d TX rings\n", priv->tx_ring_num); 1061 en_warn(priv, "Using %d RX rings\n", priv->rx_ring_num); 1062 1063 if (port_up) { 1064 err = mlx4_en_start_port(dev); 1065 if (err) 1066 en_err(priv, "Failed starting port\n"); 1067 } 1068 1069 err = mlx4_en_moderation_update(priv); 1070 1071 out: 1072 mutex_unlock(&mdev->state_lock); 1073 return err; 1074 } 1075 1076 const struct ethtool_ops mlx4_en_ethtool_ops = { 1077 .get_drvinfo = mlx4_en_get_drvinfo, 1078 .get_settings = mlx4_en_get_settings, 1079 .set_settings = mlx4_en_set_settings, 1080 .get_link = ethtool_op_get_link, 1081 .get_strings = mlx4_en_get_strings, 1082 .get_sset_count = mlx4_en_get_sset_count, 1083 .get_ethtool_stats = mlx4_en_get_ethtool_stats, 1084 .self_test = mlx4_en_self_test, 1085 .get_wol = mlx4_en_get_wol, 1086 .set_wol = mlx4_en_set_wol, 1087 .get_msglevel = mlx4_en_get_msglevel, 1088 .set_msglevel = mlx4_en_set_msglevel, 1089 .get_coalesce = mlx4_en_get_coalesce, 1090 .set_coalesce = mlx4_en_set_coalesce, 1091 .get_pauseparam = mlx4_en_get_pauseparam, 1092 .set_pauseparam = mlx4_en_set_pauseparam, 1093 .get_ringparam = mlx4_en_get_ringparam, 1094 .set_ringparam = mlx4_en_set_ringparam, 1095 .get_rxnfc = mlx4_en_get_rxnfc, 1096 .set_rxnfc = mlx4_en_set_rxnfc, 1097 .get_rxfh_indir_size = mlx4_en_get_rxfh_indir_size, 1098 .get_rxfh_indir = mlx4_en_get_rxfh_indir, 1099 .set_rxfh_indir = mlx4_en_set_rxfh_indir, 1100 .get_channels = mlx4_en_get_channels, 1101 .set_channels = mlx4_en_set_channels, 1102 }; 1103 1104 1105 1106 1107 1108