1 /* 2 * Copyright (c) 2016, 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 #include <linux/mlx5/fs.h> 34 #include <net/switchdev.h> 35 #include <net/pkt_cls.h> 36 #include <net/act_api.h> 37 #include <net/devlink.h> 38 #include <net/ipv6_stubs.h> 39 40 #include "eswitch.h" 41 #include "en.h" 42 #include "en_rep.h" 43 #include "en/params.h" 44 #include "en/txrx.h" 45 #include "en_tc.h" 46 #include "en/rep/tc.h" 47 #include "en/rep/neigh.h" 48 #include "en/rep/bridge.h" 49 #include "en/devlink.h" 50 #include "fs_core.h" 51 #include "lib/mlx5.h" 52 #include "lib/devcom.h" 53 #include "lib/vxlan.h" 54 #define CREATE_TRACE_POINTS 55 #include "diag/en_rep_tracepoint.h" 56 #include "en_accel/ipsec.h" 57 #include "en/tc/int_port.h" 58 #include "en/ptp.h" 59 #include "en/fs_ethtool.h" 60 61 #define MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE \ 62 max(0x7, MLX5E_PARAMS_MINIMUM_LOG_SQ_SIZE) 63 #define MLX5E_REP_PARAMS_DEF_NUM_CHANNELS 1 64 65 static const char mlx5e_rep_driver_name[] = "mlx5e_rep"; 66 67 static void mlx5e_rep_get_drvinfo(struct net_device *dev, 68 struct ethtool_drvinfo *drvinfo) 69 { 70 struct mlx5e_priv *priv = netdev_priv(dev); 71 struct mlx5_core_dev *mdev = priv->mdev; 72 73 strscpy(drvinfo->driver, mlx5e_rep_driver_name, 74 sizeof(drvinfo->driver)); 75 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version), 76 "%d.%d.%04d (%.16s)", 77 fw_rev_maj(mdev), fw_rev_min(mdev), 78 fw_rev_sub(mdev), mdev->board_id); 79 } 80 81 static const struct counter_desc sw_rep_stats_desc[] = { 82 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_packets) }, 83 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_bytes) }, 84 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_packets) }, 85 { MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, tx_bytes) }, 86 }; 87 88 static const struct counter_desc vport_rep_stats_desc[] = { 89 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_rx_packets) }, 90 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_rx_bytes) }, 91 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_tx_packets) }, 92 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, vport_tx_bytes) }, 93 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 94 rx_vport_rdma_unicast_packets) }, 95 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, rx_vport_rdma_unicast_bytes) }, 96 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 97 tx_vport_rdma_unicast_packets) }, 98 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, tx_vport_rdma_unicast_bytes) }, 99 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 100 rx_vport_rdma_multicast_packets) }, 101 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 102 rx_vport_rdma_multicast_bytes) }, 103 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 104 tx_vport_rdma_multicast_packets) }, 105 { MLX5E_DECLARE_STAT(struct mlx5e_rep_stats, 106 tx_vport_rdma_multicast_bytes) }, 107 }; 108 109 #define NUM_VPORT_REP_SW_COUNTERS ARRAY_SIZE(sw_rep_stats_desc) 110 #define NUM_VPORT_REP_HW_COUNTERS ARRAY_SIZE(vport_rep_stats_desc) 111 112 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(sw_rep) 113 { 114 return NUM_VPORT_REP_SW_COUNTERS; 115 } 116 117 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(sw_rep) 118 { 119 int i; 120 121 for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++) 122 strcpy(data + (idx++) * ETH_GSTRING_LEN, 123 sw_rep_stats_desc[i].format); 124 return idx; 125 } 126 127 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(sw_rep) 128 { 129 int i; 130 131 for (i = 0; i < NUM_VPORT_REP_SW_COUNTERS; i++) 132 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.sw, 133 sw_rep_stats_desc, i); 134 return idx; 135 } 136 137 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(sw_rep) 138 { 139 struct mlx5e_sw_stats *s = &priv->stats.sw; 140 struct rtnl_link_stats64 stats64 = {}; 141 142 memset(s, 0, sizeof(*s)); 143 mlx5e_fold_sw_stats64(priv, &stats64); 144 145 s->rx_packets = stats64.rx_packets; 146 s->rx_bytes = stats64.rx_bytes; 147 s->tx_packets = stats64.tx_packets; 148 s->tx_bytes = stats64.tx_bytes; 149 s->tx_queue_dropped = stats64.tx_dropped; 150 } 151 152 static MLX5E_DECLARE_STATS_GRP_OP_NUM_STATS(vport_rep) 153 { 154 return NUM_VPORT_REP_HW_COUNTERS; 155 } 156 157 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STRS(vport_rep) 158 { 159 int i; 160 161 for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++) 162 strcpy(data + (idx++) * ETH_GSTRING_LEN, vport_rep_stats_desc[i].format); 163 return idx; 164 } 165 166 static MLX5E_DECLARE_STATS_GRP_OP_FILL_STATS(vport_rep) 167 { 168 int i; 169 170 for (i = 0; i < NUM_VPORT_REP_HW_COUNTERS; i++) 171 data[idx++] = MLX5E_READ_CTR64_CPU(&priv->stats.rep_stats, 172 vport_rep_stats_desc, i); 173 return idx; 174 } 175 176 static MLX5E_DECLARE_STATS_GRP_OP_UPDATE_STATS(vport_rep) 177 { 178 struct mlx5e_rep_stats *rep_stats = &priv->stats.rep_stats; 179 int outlen = MLX5_ST_SZ_BYTES(query_vport_counter_out); 180 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 181 struct mlx5e_rep_priv *rpriv = priv->ppriv; 182 struct mlx5_eswitch_rep *rep = rpriv->rep; 183 u32 *out; 184 int err; 185 186 out = kvzalloc(outlen, GFP_KERNEL); 187 if (!out) 188 return; 189 190 err = mlx5_core_query_vport_counter(esw->dev, 1, rep->vport - 1, 0, out); 191 if (err) { 192 netdev_warn(priv->netdev, "vport %d error %d reading stats\n", 193 rep->vport, err); 194 goto out; 195 } 196 197 #define MLX5_GET_CTR(p, x) \ 198 MLX5_GET64(query_vport_counter_out, p, x) 199 /* flip tx/rx as we are reporting the counters for the switch vport */ 200 rep_stats->vport_rx_packets = 201 MLX5_GET_CTR(out, transmitted_ib_unicast.packets) + 202 MLX5_GET_CTR(out, transmitted_eth_unicast.packets) + 203 MLX5_GET_CTR(out, transmitted_ib_multicast.packets) + 204 MLX5_GET_CTR(out, transmitted_eth_multicast.packets) + 205 MLX5_GET_CTR(out, transmitted_eth_broadcast.packets); 206 207 rep_stats->vport_tx_packets = 208 MLX5_GET_CTR(out, received_ib_unicast.packets) + 209 MLX5_GET_CTR(out, received_eth_unicast.packets) + 210 MLX5_GET_CTR(out, received_ib_multicast.packets) + 211 MLX5_GET_CTR(out, received_eth_multicast.packets) + 212 MLX5_GET_CTR(out, received_eth_broadcast.packets); 213 214 rep_stats->vport_rx_bytes = 215 MLX5_GET_CTR(out, transmitted_ib_unicast.octets) + 216 MLX5_GET_CTR(out, transmitted_eth_unicast.octets) + 217 MLX5_GET_CTR(out, transmitted_ib_multicast.octets) + 218 MLX5_GET_CTR(out, transmitted_eth_broadcast.octets); 219 220 rep_stats->vport_tx_bytes = 221 MLX5_GET_CTR(out, received_ib_unicast.octets) + 222 MLX5_GET_CTR(out, received_eth_unicast.octets) + 223 MLX5_GET_CTR(out, received_ib_multicast.octets) + 224 MLX5_GET_CTR(out, received_eth_multicast.octets) + 225 MLX5_GET_CTR(out, received_eth_broadcast.octets); 226 227 rep_stats->rx_vport_rdma_unicast_packets = 228 MLX5_GET_CTR(out, transmitted_ib_unicast.packets); 229 rep_stats->tx_vport_rdma_unicast_packets = 230 MLX5_GET_CTR(out, received_ib_unicast.packets); 231 rep_stats->rx_vport_rdma_unicast_bytes = 232 MLX5_GET_CTR(out, transmitted_ib_unicast.octets); 233 rep_stats->tx_vport_rdma_unicast_bytes = 234 MLX5_GET_CTR(out, received_ib_unicast.octets); 235 rep_stats->rx_vport_rdma_multicast_packets = 236 MLX5_GET_CTR(out, transmitted_ib_multicast.packets); 237 rep_stats->tx_vport_rdma_multicast_packets = 238 MLX5_GET_CTR(out, received_ib_multicast.packets); 239 rep_stats->rx_vport_rdma_multicast_bytes = 240 MLX5_GET_CTR(out, transmitted_ib_multicast.octets); 241 rep_stats->tx_vport_rdma_multicast_bytes = 242 MLX5_GET_CTR(out, received_ib_multicast.octets); 243 244 out: 245 kvfree(out); 246 } 247 248 static void mlx5e_rep_get_strings(struct net_device *dev, 249 u32 stringset, uint8_t *data) 250 { 251 struct mlx5e_priv *priv = netdev_priv(dev); 252 253 switch (stringset) { 254 case ETH_SS_STATS: 255 mlx5e_stats_fill_strings(priv, data); 256 break; 257 } 258 } 259 260 static void mlx5e_rep_get_ethtool_stats(struct net_device *dev, 261 struct ethtool_stats *stats, u64 *data) 262 { 263 struct mlx5e_priv *priv = netdev_priv(dev); 264 265 mlx5e_ethtool_get_ethtool_stats(priv, stats, data); 266 } 267 268 static int mlx5e_rep_get_sset_count(struct net_device *dev, int sset) 269 { 270 struct mlx5e_priv *priv = netdev_priv(dev); 271 272 switch (sset) { 273 case ETH_SS_STATS: 274 return mlx5e_stats_total_num(priv); 275 default: 276 return -EOPNOTSUPP; 277 } 278 } 279 280 static void 281 mlx5e_rep_get_ringparam(struct net_device *dev, 282 struct ethtool_ringparam *param, 283 struct kernel_ethtool_ringparam *kernel_param, 284 struct netlink_ext_ack *extack) 285 { 286 struct mlx5e_priv *priv = netdev_priv(dev); 287 288 mlx5e_ethtool_get_ringparam(priv, param, kernel_param); 289 } 290 291 static int 292 mlx5e_rep_set_ringparam(struct net_device *dev, 293 struct ethtool_ringparam *param, 294 struct kernel_ethtool_ringparam *kernel_param, 295 struct netlink_ext_ack *extack) 296 { 297 struct mlx5e_priv *priv = netdev_priv(dev); 298 299 return mlx5e_ethtool_set_ringparam(priv, param); 300 } 301 302 static void mlx5e_rep_get_channels(struct net_device *dev, 303 struct ethtool_channels *ch) 304 { 305 struct mlx5e_priv *priv = netdev_priv(dev); 306 307 mlx5e_ethtool_get_channels(priv, ch); 308 } 309 310 static int mlx5e_rep_set_channels(struct net_device *dev, 311 struct ethtool_channels *ch) 312 { 313 struct mlx5e_priv *priv = netdev_priv(dev); 314 315 return mlx5e_ethtool_set_channels(priv, ch); 316 } 317 318 static int mlx5e_rep_get_coalesce(struct net_device *netdev, 319 struct ethtool_coalesce *coal, 320 struct kernel_ethtool_coalesce *kernel_coal, 321 struct netlink_ext_ack *extack) 322 { 323 struct mlx5e_priv *priv = netdev_priv(netdev); 324 325 return mlx5e_ethtool_get_coalesce(priv, coal, kernel_coal); 326 } 327 328 static int mlx5e_rep_set_coalesce(struct net_device *netdev, 329 struct ethtool_coalesce *coal, 330 struct kernel_ethtool_coalesce *kernel_coal, 331 struct netlink_ext_ack *extack) 332 { 333 struct mlx5e_priv *priv = netdev_priv(netdev); 334 335 return mlx5e_ethtool_set_coalesce(priv, coal, kernel_coal, extack); 336 } 337 338 static u32 mlx5e_rep_get_rxfh_key_size(struct net_device *netdev) 339 { 340 struct mlx5e_priv *priv = netdev_priv(netdev); 341 342 return mlx5e_ethtool_get_rxfh_key_size(priv); 343 } 344 345 static u32 mlx5e_rep_get_rxfh_indir_size(struct net_device *netdev) 346 { 347 struct mlx5e_priv *priv = netdev_priv(netdev); 348 349 return mlx5e_ethtool_get_rxfh_indir_size(priv); 350 } 351 352 static const struct ethtool_ops mlx5e_rep_ethtool_ops = { 353 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 354 ETHTOOL_COALESCE_MAX_FRAMES | 355 ETHTOOL_COALESCE_USE_ADAPTIVE, 356 .get_drvinfo = mlx5e_rep_get_drvinfo, 357 .get_link = ethtool_op_get_link, 358 .get_strings = mlx5e_rep_get_strings, 359 .get_sset_count = mlx5e_rep_get_sset_count, 360 .get_ethtool_stats = mlx5e_rep_get_ethtool_stats, 361 .get_ringparam = mlx5e_rep_get_ringparam, 362 .set_ringparam = mlx5e_rep_set_ringparam, 363 .get_channels = mlx5e_rep_get_channels, 364 .set_channels = mlx5e_rep_set_channels, 365 .get_coalesce = mlx5e_rep_get_coalesce, 366 .set_coalesce = mlx5e_rep_set_coalesce, 367 .get_rxfh_key_size = mlx5e_rep_get_rxfh_key_size, 368 .get_rxfh_indir_size = mlx5e_rep_get_rxfh_indir_size, 369 }; 370 371 static void mlx5e_sqs2vport_stop(struct mlx5_eswitch *esw, 372 struct mlx5_eswitch_rep *rep) 373 { 374 struct mlx5e_rep_sq *rep_sq, *tmp; 375 struct mlx5e_rep_priv *rpriv; 376 377 if (esw->mode != MLX5_ESWITCH_OFFLOADS) 378 return; 379 380 rpriv = mlx5e_rep_to_rep_priv(rep); 381 list_for_each_entry_safe(rep_sq, tmp, &rpriv->vport_sqs_list, list) { 382 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule); 383 if (rep_sq->send_to_vport_rule_peer) 384 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule_peer); 385 list_del(&rep_sq->list); 386 kfree(rep_sq); 387 } 388 } 389 390 static int mlx5e_sqs2vport_start(struct mlx5_eswitch *esw, 391 struct mlx5_eswitch_rep *rep, 392 u32 *sqns_array, int sqns_num) 393 { 394 struct mlx5_eswitch *peer_esw = NULL; 395 struct mlx5_flow_handle *flow_rule; 396 struct mlx5e_rep_priv *rpriv; 397 struct mlx5e_rep_sq *rep_sq; 398 int err; 399 int i; 400 401 if (esw->mode != MLX5_ESWITCH_OFFLOADS) 402 return 0; 403 404 rpriv = mlx5e_rep_to_rep_priv(rep); 405 if (mlx5_devcom_is_paired(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS)) 406 peer_esw = mlx5_devcom_get_peer_data(esw->dev->priv.devcom, 407 MLX5_DEVCOM_ESW_OFFLOADS); 408 409 for (i = 0; i < sqns_num; i++) { 410 rep_sq = kzalloc(sizeof(*rep_sq), GFP_KERNEL); 411 if (!rep_sq) { 412 err = -ENOMEM; 413 goto out_err; 414 } 415 416 /* Add re-inject rule to the PF/representor sqs */ 417 flow_rule = mlx5_eswitch_add_send_to_vport_rule(esw, esw, rep, 418 sqns_array[i]); 419 if (IS_ERR(flow_rule)) { 420 err = PTR_ERR(flow_rule); 421 kfree(rep_sq); 422 goto out_err; 423 } 424 rep_sq->send_to_vport_rule = flow_rule; 425 rep_sq->sqn = sqns_array[i]; 426 427 if (peer_esw) { 428 flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw, 429 rep, sqns_array[i]); 430 if (IS_ERR(flow_rule)) { 431 err = PTR_ERR(flow_rule); 432 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule); 433 kfree(rep_sq); 434 goto out_err; 435 } 436 rep_sq->send_to_vport_rule_peer = flow_rule; 437 } 438 439 list_add(&rep_sq->list, &rpriv->vport_sqs_list); 440 } 441 442 if (peer_esw) 443 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS); 444 445 return 0; 446 447 out_err: 448 mlx5e_sqs2vport_stop(esw, rep); 449 450 if (peer_esw) 451 mlx5_devcom_release_peer_data(esw->dev->priv.devcom, MLX5_DEVCOM_ESW_OFFLOADS); 452 453 return err; 454 } 455 456 static int 457 mlx5e_add_sqs_fwd_rules(struct mlx5e_priv *priv) 458 { 459 int sqs_per_channel = mlx5e_get_dcb_num_tc(&priv->channels.params); 460 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 461 bool is_uplink_rep = mlx5e_is_uplink_rep(priv); 462 struct mlx5e_rep_priv *rpriv = priv->ppriv; 463 struct mlx5_eswitch_rep *rep = rpriv->rep; 464 int n, tc, nch, num_sqs = 0; 465 struct mlx5e_channel *c; 466 int err = -ENOMEM; 467 bool ptp_sq; 468 u32 *sqs; 469 470 ptp_sq = !!(priv->channels.ptp && 471 MLX5E_GET_PFLAG(&priv->channels.params, MLX5E_PFLAG_TX_PORT_TS)); 472 nch = priv->channels.num + ptp_sq; 473 /* +2 for xdpsqs, they don't exist on the ptp channel but will not be 474 * counted for by num_sqs. 475 */ 476 if (is_uplink_rep) 477 sqs_per_channel += 2; 478 479 sqs = kvcalloc(nch * sqs_per_channel, sizeof(*sqs), GFP_KERNEL); 480 if (!sqs) 481 goto out; 482 483 for (n = 0; n < priv->channels.num; n++) { 484 c = priv->channels.c[n]; 485 for (tc = 0; tc < c->num_tc; tc++) 486 sqs[num_sqs++] = c->sq[tc].sqn; 487 488 if (is_uplink_rep) { 489 if (c->xdp) 490 sqs[num_sqs++] = c->rq_xdpsq.sqn; 491 492 sqs[num_sqs++] = c->xdpsq.sqn; 493 } 494 } 495 if (ptp_sq) { 496 struct mlx5e_ptp *ptp_ch = priv->channels.ptp; 497 498 for (tc = 0; tc < ptp_ch->num_tc; tc++) 499 sqs[num_sqs++] = ptp_ch->ptpsq[tc].txqsq.sqn; 500 } 501 502 err = mlx5e_sqs2vport_start(esw, rep, sqs, num_sqs); 503 kvfree(sqs); 504 505 out: 506 if (err) 507 netdev_warn(priv->netdev, "Failed to add SQs FWD rules %d\n", err); 508 return err; 509 } 510 511 static void 512 mlx5e_remove_sqs_fwd_rules(struct mlx5e_priv *priv) 513 { 514 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 515 struct mlx5e_rep_priv *rpriv = priv->ppriv; 516 struct mlx5_eswitch_rep *rep = rpriv->rep; 517 518 mlx5e_sqs2vport_stop(esw, rep); 519 } 520 521 static int 522 mlx5e_rep_add_meta_tunnel_rule(struct mlx5e_priv *priv) 523 { 524 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 525 struct mlx5e_rep_priv *rpriv = priv->ppriv; 526 struct mlx5_eswitch_rep *rep = rpriv->rep; 527 struct mlx5_flow_handle *flow_rule; 528 struct mlx5_flow_group *g; 529 530 g = esw->fdb_table.offloads.send_to_vport_meta_grp; 531 if (!g) 532 return 0; 533 534 flow_rule = mlx5_eswitch_add_send_to_vport_meta_rule(esw, rep->vport); 535 if (IS_ERR(flow_rule)) 536 return PTR_ERR(flow_rule); 537 538 rpriv->send_to_vport_meta_rule = flow_rule; 539 540 return 0; 541 } 542 543 static void 544 mlx5e_rep_del_meta_tunnel_rule(struct mlx5e_priv *priv) 545 { 546 struct mlx5e_rep_priv *rpriv = priv->ppriv; 547 548 if (rpriv->send_to_vport_meta_rule) 549 mlx5_eswitch_del_send_to_vport_meta_rule(rpriv->send_to_vport_meta_rule); 550 } 551 552 void mlx5e_rep_activate_channels(struct mlx5e_priv *priv) 553 { 554 mlx5e_add_sqs_fwd_rules(priv); 555 mlx5e_rep_add_meta_tunnel_rule(priv); 556 } 557 558 void mlx5e_rep_deactivate_channels(struct mlx5e_priv *priv) 559 { 560 mlx5e_rep_del_meta_tunnel_rule(priv); 561 mlx5e_remove_sqs_fwd_rules(priv); 562 } 563 564 static int mlx5e_rep_open(struct net_device *dev) 565 { 566 struct mlx5e_priv *priv = netdev_priv(dev); 567 struct mlx5e_rep_priv *rpriv = priv->ppriv; 568 struct mlx5_eswitch_rep *rep = rpriv->rep; 569 int err; 570 571 mutex_lock(&priv->state_lock); 572 err = mlx5e_open_locked(dev); 573 if (err) 574 goto unlock; 575 576 if (!mlx5_modify_vport_admin_state(priv->mdev, 577 MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 578 rep->vport, 1, 579 MLX5_VPORT_ADMIN_STATE_UP)) 580 netif_carrier_on(dev); 581 582 unlock: 583 mutex_unlock(&priv->state_lock); 584 return err; 585 } 586 587 static int mlx5e_rep_close(struct net_device *dev) 588 { 589 struct mlx5e_priv *priv = netdev_priv(dev); 590 struct mlx5e_rep_priv *rpriv = priv->ppriv; 591 struct mlx5_eswitch_rep *rep = rpriv->rep; 592 int ret; 593 594 mutex_lock(&priv->state_lock); 595 mlx5_modify_vport_admin_state(priv->mdev, 596 MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 597 rep->vport, 1, 598 MLX5_VPORT_ADMIN_STATE_DOWN); 599 ret = mlx5e_close_locked(dev); 600 mutex_unlock(&priv->state_lock); 601 return ret; 602 } 603 604 bool mlx5e_is_uplink_rep(struct mlx5e_priv *priv) 605 { 606 struct mlx5e_rep_priv *rpriv = priv->ppriv; 607 struct mlx5_eswitch_rep *rep; 608 609 if (!MLX5_ESWITCH_MANAGER(priv->mdev)) 610 return false; 611 612 if (!rpriv) /* non vport rep mlx5e instances don't use this field */ 613 return false; 614 615 rep = rpriv->rep; 616 return (rep->vport == MLX5_VPORT_UPLINK); 617 } 618 619 bool mlx5e_rep_has_offload_stats(const struct net_device *dev, int attr_id) 620 { 621 switch (attr_id) { 622 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 623 return true; 624 } 625 626 return false; 627 } 628 629 static int 630 mlx5e_get_sw_stats64(const struct net_device *dev, 631 struct rtnl_link_stats64 *stats) 632 { 633 struct mlx5e_priv *priv = netdev_priv(dev); 634 635 mlx5e_fold_sw_stats64(priv, stats); 636 return 0; 637 } 638 639 int mlx5e_rep_get_offload_stats(int attr_id, const struct net_device *dev, 640 void *sp) 641 { 642 switch (attr_id) { 643 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 644 return mlx5e_get_sw_stats64(dev, sp); 645 } 646 647 return -EINVAL; 648 } 649 650 static void 651 mlx5e_rep_get_stats(struct net_device *dev, struct rtnl_link_stats64 *stats) 652 { 653 struct mlx5e_priv *priv = netdev_priv(dev); 654 655 /* update HW stats in background for next time */ 656 mlx5e_queue_update_stats(priv); 657 memcpy(stats, &priv->stats.vf_vport, sizeof(*stats)); 658 } 659 660 static int mlx5e_rep_change_mtu(struct net_device *netdev, int new_mtu) 661 { 662 return mlx5e_change_mtu(netdev, new_mtu, NULL); 663 } 664 665 static int mlx5e_rep_change_carrier(struct net_device *dev, bool new_carrier) 666 { 667 struct mlx5e_priv *priv = netdev_priv(dev); 668 struct mlx5e_rep_priv *rpriv = priv->ppriv; 669 struct mlx5_eswitch_rep *rep = rpriv->rep; 670 int err; 671 672 if (new_carrier) { 673 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 674 rep->vport, 1, MLX5_VPORT_ADMIN_STATE_UP); 675 if (err) 676 return err; 677 netif_carrier_on(dev); 678 } else { 679 err = mlx5_modify_vport_admin_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_ESW_VPORT, 680 rep->vport, 1, MLX5_VPORT_ADMIN_STATE_DOWN); 681 if (err) 682 return err; 683 netif_carrier_off(dev); 684 } 685 return 0; 686 } 687 688 static const struct net_device_ops mlx5e_netdev_ops_rep = { 689 .ndo_open = mlx5e_rep_open, 690 .ndo_stop = mlx5e_rep_close, 691 .ndo_start_xmit = mlx5e_xmit, 692 .ndo_setup_tc = mlx5e_rep_setup_tc, 693 .ndo_get_stats64 = mlx5e_rep_get_stats, 694 .ndo_has_offload_stats = mlx5e_rep_has_offload_stats, 695 .ndo_get_offload_stats = mlx5e_rep_get_offload_stats, 696 .ndo_change_mtu = mlx5e_rep_change_mtu, 697 .ndo_change_carrier = mlx5e_rep_change_carrier, 698 }; 699 700 bool mlx5e_eswitch_uplink_rep(const struct net_device *netdev) 701 { 702 return netdev->netdev_ops == &mlx5e_netdev_ops && 703 mlx5e_is_uplink_rep(netdev_priv(netdev)); 704 } 705 706 bool mlx5e_eswitch_vf_rep(const struct net_device *netdev) 707 { 708 return netdev->netdev_ops == &mlx5e_netdev_ops_rep; 709 } 710 711 /* One indirect TIR set for outer. Inner not supported in reps. */ 712 #define REP_NUM_INDIR_TIRS MLX5E_NUM_INDIR_TIRS 713 714 static int mlx5e_rep_max_nch_limit(struct mlx5_core_dev *mdev) 715 { 716 int max_tir_num = 1 << MLX5_CAP_GEN(mdev, log_max_tir); 717 int num_vports = mlx5_eswitch_get_total_vports(mdev); 718 719 return (max_tir_num - mlx5e_get_pf_num_tirs(mdev) 720 - (num_vports * REP_NUM_INDIR_TIRS)) / num_vports; 721 } 722 723 static void mlx5e_build_rep_params(struct net_device *netdev) 724 { 725 struct mlx5e_priv *priv = netdev_priv(netdev); 726 struct mlx5e_rep_priv *rpriv = priv->ppriv; 727 struct mlx5_eswitch_rep *rep = rpriv->rep; 728 struct mlx5_core_dev *mdev = priv->mdev; 729 struct mlx5e_params *params; 730 731 u8 cq_period_mode = MLX5_CAP_GEN(mdev, cq_period_start_from_cqe) ? 732 MLX5_CQ_PERIOD_MODE_START_FROM_CQE : 733 MLX5_CQ_PERIOD_MODE_START_FROM_EQE; 734 735 params = &priv->channels.params; 736 737 params->num_channels = MLX5E_REP_PARAMS_DEF_NUM_CHANNELS; 738 params->hard_mtu = MLX5E_ETH_HARD_MTU; 739 params->sw_mtu = netdev->mtu; 740 741 /* SQ */ 742 if (rep->vport == MLX5_VPORT_UPLINK) 743 params->log_sq_size = MLX5E_PARAMS_DEFAULT_LOG_SQ_SIZE; 744 else 745 params->log_sq_size = MLX5E_REP_PARAMS_DEF_LOG_SQ_SIZE; 746 747 /* RQ */ 748 mlx5e_build_rq_params(mdev, params); 749 750 /* update XDP supported features */ 751 mlx5e_set_xdp_feature(netdev); 752 753 /* CQ moderation params */ 754 params->rx_dim_enabled = MLX5_CAP_GEN(mdev, cq_moderation); 755 mlx5e_set_rx_cq_mode_params(params, cq_period_mode); 756 757 params->mqprio.num_tc = 1; 758 if (rep->vport != MLX5_VPORT_UPLINK) 759 params->vlan_strip_disable = true; 760 761 mlx5_query_min_inline(mdev, ¶ms->tx_min_inline_mode); 762 } 763 764 static void mlx5e_build_rep_netdev(struct net_device *netdev, 765 struct mlx5_core_dev *mdev) 766 { 767 SET_NETDEV_DEV(netdev, mdev->device); 768 netdev->netdev_ops = &mlx5e_netdev_ops_rep; 769 eth_hw_addr_random(netdev); 770 netdev->ethtool_ops = &mlx5e_rep_ethtool_ops; 771 772 netdev->watchdog_timeo = 15 * HZ; 773 774 #if IS_ENABLED(CONFIG_MLX5_CLS_ACT) 775 netdev->hw_features |= NETIF_F_HW_TC; 776 #endif 777 netdev->hw_features |= NETIF_F_SG; 778 netdev->hw_features |= NETIF_F_IP_CSUM; 779 netdev->hw_features |= NETIF_F_IPV6_CSUM; 780 netdev->hw_features |= NETIF_F_GRO; 781 netdev->hw_features |= NETIF_F_TSO; 782 netdev->hw_features |= NETIF_F_TSO6; 783 netdev->hw_features |= NETIF_F_RXCSUM; 784 785 netdev->features |= netdev->hw_features; 786 netdev->features |= NETIF_F_NETNS_LOCAL; 787 } 788 789 static int mlx5e_init_rep(struct mlx5_core_dev *mdev, 790 struct net_device *netdev) 791 { 792 struct mlx5e_priv *priv = netdev_priv(netdev); 793 794 priv->fs = 795 mlx5e_fs_init(priv->profile, mdev, 796 !test_bit(MLX5E_STATE_DESTROYING, &priv->state), 797 priv->dfs_root); 798 if (!priv->fs) { 799 netdev_err(priv->netdev, "FS allocation failed\n"); 800 return -ENOMEM; 801 } 802 803 mlx5e_build_rep_params(netdev); 804 mlx5e_timestamp_init(priv); 805 806 return 0; 807 } 808 809 static int mlx5e_init_ul_rep(struct mlx5_core_dev *mdev, 810 struct net_device *netdev) 811 { 812 struct mlx5e_priv *priv = netdev_priv(netdev); 813 814 priv->fs = mlx5e_fs_init(priv->profile, mdev, 815 !test_bit(MLX5E_STATE_DESTROYING, &priv->state), 816 priv->dfs_root); 817 if (!priv->fs) { 818 netdev_err(priv->netdev, "FS allocation failed\n"); 819 return -ENOMEM; 820 } 821 822 mlx5e_vxlan_set_netdev_info(priv); 823 mlx5e_build_rep_params(netdev); 824 mlx5e_timestamp_init(priv); 825 return 0; 826 } 827 828 static void mlx5e_cleanup_rep(struct mlx5e_priv *priv) 829 { 830 mlx5e_fs_cleanup(priv->fs); 831 } 832 833 static int mlx5e_create_rep_ttc_table(struct mlx5e_priv *priv) 834 { 835 struct mlx5e_rep_priv *rpriv = priv->ppriv; 836 struct mlx5_eswitch_rep *rep = rpriv->rep; 837 struct ttc_params ttc_params = {}; 838 int err; 839 840 mlx5e_fs_set_ns(priv->fs, 841 mlx5_get_flow_namespace(priv->mdev, 842 MLX5_FLOW_NAMESPACE_KERNEL), false); 843 844 /* The inner_ttc in the ttc params is intentionally not set */ 845 mlx5e_set_ttc_params(priv->fs, priv->rx_res, &ttc_params, false); 846 847 if (rep->vport != MLX5_VPORT_UPLINK) 848 /* To give uplik rep TTC a lower level for chaining from root ft */ 849 ttc_params.ft_attr.level = MLX5E_TTC_FT_LEVEL + 1; 850 851 mlx5e_fs_set_ttc(priv->fs, mlx5_create_ttc_table(priv->mdev, &ttc_params), false); 852 if (IS_ERR(mlx5e_fs_get_ttc(priv->fs, false))) { 853 err = PTR_ERR(mlx5e_fs_get_ttc(priv->fs, false)); 854 netdev_err(priv->netdev, "Failed to create rep ttc table, err=%d\n", 855 err); 856 return err; 857 } 858 return 0; 859 } 860 861 static int mlx5e_create_rep_root_ft(struct mlx5e_priv *priv) 862 { 863 struct mlx5e_rep_priv *rpriv = priv->ppriv; 864 struct mlx5_eswitch_rep *rep = rpriv->rep; 865 struct mlx5_flow_table_attr ft_attr = {}; 866 struct mlx5_flow_namespace *ns; 867 int err = 0; 868 869 if (rep->vport != MLX5_VPORT_UPLINK) { 870 /* non uplik reps will skip any bypass tables and go directly to 871 * their own ttc 872 */ 873 rpriv->root_ft = mlx5_get_ttc_flow_table(mlx5e_fs_get_ttc(priv->fs, false)); 874 return 0; 875 } 876 877 /* uplink root ft will be used to auto chain, to ethtool or ttc tables */ 878 ns = mlx5_get_flow_namespace(priv->mdev, MLX5_FLOW_NAMESPACE_OFFLOADS); 879 if (!ns) { 880 netdev_err(priv->netdev, "Failed to get reps offloads namespace\n"); 881 return -EOPNOTSUPP; 882 } 883 884 ft_attr.max_fte = 0; /* Empty table, miss rule will always point to next table */ 885 ft_attr.prio = 1; 886 ft_attr.level = 1; 887 888 rpriv->root_ft = mlx5_create_flow_table(ns, &ft_attr); 889 if (IS_ERR(rpriv->root_ft)) { 890 err = PTR_ERR(rpriv->root_ft); 891 rpriv->root_ft = NULL; 892 } 893 894 return err; 895 } 896 897 static void mlx5e_destroy_rep_root_ft(struct mlx5e_priv *priv) 898 { 899 struct mlx5e_rep_priv *rpriv = priv->ppriv; 900 struct mlx5_eswitch_rep *rep = rpriv->rep; 901 902 if (rep->vport != MLX5_VPORT_UPLINK) 903 return; 904 mlx5_destroy_flow_table(rpriv->root_ft); 905 } 906 907 static int mlx5e_create_rep_vport_rx_rule(struct mlx5e_priv *priv) 908 { 909 struct mlx5_eswitch *esw = priv->mdev->priv.eswitch; 910 struct mlx5e_rep_priv *rpriv = priv->ppriv; 911 struct mlx5_eswitch_rep *rep = rpriv->rep; 912 struct mlx5_flow_handle *flow_rule; 913 struct mlx5_flow_destination dest; 914 915 dest.type = MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE; 916 dest.ft = rpriv->root_ft; 917 918 flow_rule = mlx5_eswitch_create_vport_rx_rule(esw, rep->vport, &dest); 919 if (IS_ERR(flow_rule)) 920 return PTR_ERR(flow_rule); 921 rpriv->vport_rx_rule = flow_rule; 922 return 0; 923 } 924 925 static void rep_vport_rx_rule_destroy(struct mlx5e_priv *priv) 926 { 927 struct mlx5e_rep_priv *rpriv = priv->ppriv; 928 929 if (!rpriv->vport_rx_rule) 930 return; 931 932 mlx5_del_flow_rules(rpriv->vport_rx_rule); 933 rpriv->vport_rx_rule = NULL; 934 } 935 936 int mlx5e_rep_bond_update(struct mlx5e_priv *priv, bool cleanup) 937 { 938 rep_vport_rx_rule_destroy(priv); 939 940 return cleanup ? 0 : mlx5e_create_rep_vport_rx_rule(priv); 941 } 942 943 static int mlx5e_init_rep_rx(struct mlx5e_priv *priv) 944 { 945 struct mlx5_core_dev *mdev = priv->mdev; 946 int err; 947 948 priv->rx_res = mlx5e_rx_res_alloc(); 949 if (!priv->rx_res) { 950 err = -ENOMEM; 951 goto err_free_fs; 952 } 953 954 mlx5e_fs_init_l2_addr(priv->fs, priv->netdev); 955 956 err = mlx5e_open_drop_rq(priv, &priv->drop_rq); 957 if (err) { 958 mlx5_core_err(mdev, "open drop rq failed, %d\n", err); 959 return err; 960 } 961 962 err = mlx5e_rx_res_init(priv->rx_res, priv->mdev, 0, 963 priv->max_nch, priv->drop_rq.rqn, 964 &priv->channels.params.packet_merge, 965 priv->channels.params.num_channels); 966 if (err) 967 goto err_close_drop_rq; 968 969 err = mlx5e_create_rep_ttc_table(priv); 970 if (err) 971 goto err_destroy_rx_res; 972 973 err = mlx5e_create_rep_root_ft(priv); 974 if (err) 975 goto err_destroy_ttc_table; 976 977 err = mlx5e_create_rep_vport_rx_rule(priv); 978 if (err) 979 goto err_destroy_root_ft; 980 981 mlx5e_ethtool_init_steering(priv->fs); 982 983 return 0; 984 985 err_destroy_root_ft: 986 mlx5e_destroy_rep_root_ft(priv); 987 err_destroy_ttc_table: 988 mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false)); 989 err_destroy_rx_res: 990 mlx5e_rx_res_destroy(priv->rx_res); 991 err_close_drop_rq: 992 mlx5e_close_drop_rq(&priv->drop_rq); 993 mlx5e_rx_res_free(priv->rx_res); 994 priv->rx_res = NULL; 995 err_free_fs: 996 mlx5e_fs_cleanup(priv->fs); 997 return err; 998 } 999 1000 static void mlx5e_cleanup_rep_rx(struct mlx5e_priv *priv) 1001 { 1002 mlx5e_ethtool_cleanup_steering(priv->fs); 1003 rep_vport_rx_rule_destroy(priv); 1004 mlx5e_destroy_rep_root_ft(priv); 1005 mlx5_destroy_ttc_table(mlx5e_fs_get_ttc(priv->fs, false)); 1006 mlx5e_rx_res_destroy(priv->rx_res); 1007 mlx5e_close_drop_rq(&priv->drop_rq); 1008 mlx5e_rx_res_free(priv->rx_res); 1009 priv->rx_res = NULL; 1010 } 1011 1012 static void mlx5e_rep_mpesw_work(struct work_struct *work) 1013 { 1014 struct mlx5_rep_uplink_priv *uplink_priv = 1015 container_of(work, struct mlx5_rep_uplink_priv, 1016 mpesw_work); 1017 struct mlx5e_rep_priv *rpriv = 1018 container_of(uplink_priv, struct mlx5e_rep_priv, 1019 uplink_priv); 1020 struct mlx5e_priv *priv = netdev_priv(rpriv->netdev); 1021 1022 rep_vport_rx_rule_destroy(priv); 1023 mlx5e_create_rep_vport_rx_rule(priv); 1024 } 1025 1026 static int mlx5e_init_ul_rep_rx(struct mlx5e_priv *priv) 1027 { 1028 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1029 int err; 1030 1031 mlx5e_create_q_counters(priv); 1032 err = mlx5e_init_rep_rx(priv); 1033 if (err) 1034 goto out; 1035 1036 mlx5e_tc_int_port_init_rep_rx(priv); 1037 1038 INIT_WORK(&rpriv->uplink_priv.mpesw_work, mlx5e_rep_mpesw_work); 1039 1040 out: 1041 return err; 1042 } 1043 1044 static void mlx5e_cleanup_ul_rep_rx(struct mlx5e_priv *priv) 1045 { 1046 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1047 1048 cancel_work_sync(&rpriv->uplink_priv.mpesw_work); 1049 mlx5e_tc_int_port_cleanup_rep_rx(priv); 1050 mlx5e_cleanup_rep_rx(priv); 1051 mlx5e_destroy_q_counters(priv); 1052 } 1053 1054 static int mlx5e_init_uplink_rep_tx(struct mlx5e_rep_priv *rpriv) 1055 { 1056 struct mlx5_rep_uplink_priv *uplink_priv; 1057 struct net_device *netdev; 1058 struct mlx5e_priv *priv; 1059 int err; 1060 1061 netdev = rpriv->netdev; 1062 priv = netdev_priv(netdev); 1063 uplink_priv = &rpriv->uplink_priv; 1064 1065 err = mlx5e_rep_tc_init(rpriv); 1066 if (err) 1067 return err; 1068 1069 mlx5_init_port_tun_entropy(&uplink_priv->tun_entropy, priv->mdev); 1070 1071 mlx5e_rep_bond_init(rpriv); 1072 err = mlx5e_rep_tc_netdevice_event_register(rpriv); 1073 if (err) { 1074 mlx5_core_err(priv->mdev, "Failed to register netdev notifier, err: %d\n", 1075 err); 1076 goto err_event_reg; 1077 } 1078 1079 return 0; 1080 1081 err_event_reg: 1082 mlx5e_rep_bond_cleanup(rpriv); 1083 mlx5e_rep_tc_cleanup(rpriv); 1084 return err; 1085 } 1086 1087 static void mlx5e_cleanup_uplink_rep_tx(struct mlx5e_rep_priv *rpriv) 1088 { 1089 mlx5e_rep_tc_netdevice_event_unregister(rpriv); 1090 mlx5e_rep_bond_cleanup(rpriv); 1091 mlx5e_rep_tc_cleanup(rpriv); 1092 } 1093 1094 static int mlx5e_init_rep_tx(struct mlx5e_priv *priv) 1095 { 1096 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1097 int err; 1098 1099 err = mlx5e_create_tises(priv); 1100 if (err) { 1101 mlx5_core_warn(priv->mdev, "create tises failed, %d\n", err); 1102 return err; 1103 } 1104 1105 if (rpriv->rep->vport == MLX5_VPORT_UPLINK) { 1106 err = mlx5e_init_uplink_rep_tx(rpriv); 1107 if (err) 1108 goto err_init_tx; 1109 } 1110 1111 err = mlx5e_tc_ht_init(&rpriv->tc_ht); 1112 if (err) 1113 goto err_ht_init; 1114 1115 return 0; 1116 1117 err_ht_init: 1118 if (rpriv->rep->vport == MLX5_VPORT_UPLINK) 1119 mlx5e_cleanup_uplink_rep_tx(rpriv); 1120 err_init_tx: 1121 mlx5e_destroy_tises(priv); 1122 return err; 1123 } 1124 1125 static void mlx5e_cleanup_rep_tx(struct mlx5e_priv *priv) 1126 { 1127 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1128 1129 mlx5e_tc_ht_cleanup(&rpriv->tc_ht); 1130 1131 if (rpriv->rep->vport == MLX5_VPORT_UPLINK) 1132 mlx5e_cleanup_uplink_rep_tx(rpriv); 1133 1134 mlx5e_destroy_tises(priv); 1135 } 1136 1137 static void mlx5e_rep_enable(struct mlx5e_priv *priv) 1138 { 1139 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1140 1141 mlx5e_set_netdev_mtu_boundaries(priv); 1142 mlx5e_rep_neigh_init(rpriv); 1143 } 1144 1145 static void mlx5e_rep_disable(struct mlx5e_priv *priv) 1146 { 1147 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1148 1149 mlx5e_rep_neigh_cleanup(rpriv); 1150 } 1151 1152 static int mlx5e_update_rep_rx(struct mlx5e_priv *priv) 1153 { 1154 return 0; 1155 } 1156 1157 static int mlx5e_rep_event_mpesw(struct mlx5e_priv *priv) 1158 { 1159 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1160 struct mlx5_eswitch_rep *rep = rpriv->rep; 1161 1162 if (rep->vport != MLX5_VPORT_UPLINK) 1163 return NOTIFY_DONE; 1164 1165 queue_work(priv->wq, &rpriv->uplink_priv.mpesw_work); 1166 1167 return NOTIFY_OK; 1168 } 1169 1170 static int uplink_rep_async_event(struct notifier_block *nb, unsigned long event, void *data) 1171 { 1172 struct mlx5e_priv *priv = container_of(nb, struct mlx5e_priv, events_nb); 1173 1174 if (event == MLX5_EVENT_TYPE_PORT_CHANGE) { 1175 struct mlx5_eqe *eqe = data; 1176 1177 switch (eqe->sub_type) { 1178 case MLX5_PORT_CHANGE_SUBTYPE_DOWN: 1179 case MLX5_PORT_CHANGE_SUBTYPE_ACTIVE: 1180 queue_work(priv->wq, &priv->update_carrier_work); 1181 break; 1182 default: 1183 return NOTIFY_DONE; 1184 } 1185 1186 return NOTIFY_OK; 1187 } 1188 1189 if (event == MLX5_DEV_EVENT_PORT_AFFINITY) 1190 return mlx5e_rep_tc_event_port_affinity(priv); 1191 else if (event == MLX5_DEV_EVENT_MULTIPORT_ESW) 1192 return mlx5e_rep_event_mpesw(priv); 1193 1194 return NOTIFY_DONE; 1195 } 1196 1197 static void mlx5e_uplink_rep_enable(struct mlx5e_priv *priv) 1198 { 1199 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1200 struct net_device *netdev = priv->netdev; 1201 struct mlx5_core_dev *mdev = priv->mdev; 1202 u16 max_mtu; 1203 1204 mlx5e_ipsec_init(priv); 1205 1206 netdev->min_mtu = ETH_MIN_MTU; 1207 mlx5_query_port_max_mtu(priv->mdev, &max_mtu, 1); 1208 netdev->max_mtu = MLX5E_HW2SW_MTU(&priv->channels.params, max_mtu); 1209 mlx5e_set_dev_port_mtu(priv); 1210 1211 mlx5e_rep_tc_enable(priv); 1212 1213 if (MLX5_CAP_GEN(mdev, uplink_follow)) 1214 mlx5_modify_vport_admin_state(mdev, MLX5_VPORT_STATE_OP_MOD_UPLINK, 1215 0, 0, MLX5_VPORT_ADMIN_STATE_AUTO); 1216 mlx5_lag_add_netdev(mdev, netdev); 1217 priv->events_nb.notifier_call = uplink_rep_async_event; 1218 mlx5_notifier_register(mdev, &priv->events_nb); 1219 mlx5e_dcbnl_initialize(priv); 1220 mlx5e_dcbnl_init_app(priv); 1221 mlx5e_rep_neigh_init(rpriv); 1222 mlx5e_rep_bridge_init(priv); 1223 1224 netdev->wanted_features |= NETIF_F_HW_TC; 1225 1226 rtnl_lock(); 1227 if (netif_running(netdev)) 1228 mlx5e_open(netdev); 1229 udp_tunnel_nic_reset_ntf(priv->netdev); 1230 netif_device_attach(netdev); 1231 rtnl_unlock(); 1232 } 1233 1234 static void mlx5e_uplink_rep_disable(struct mlx5e_priv *priv) 1235 { 1236 struct mlx5e_rep_priv *rpriv = priv->ppriv; 1237 struct mlx5_core_dev *mdev = priv->mdev; 1238 1239 rtnl_lock(); 1240 if (netif_running(priv->netdev)) 1241 mlx5e_close(priv->netdev); 1242 netif_device_detach(priv->netdev); 1243 rtnl_unlock(); 1244 1245 mlx5e_rep_bridge_cleanup(priv); 1246 mlx5e_rep_neigh_cleanup(rpriv); 1247 mlx5e_dcbnl_delete_app(priv); 1248 mlx5_notifier_unregister(mdev, &priv->events_nb); 1249 mlx5e_rep_tc_disable(priv); 1250 mlx5_lag_remove_netdev(mdev, priv->netdev); 1251 mlx5_vxlan_reset_to_default(mdev->vxlan); 1252 1253 mlx5e_ipsec_cleanup(priv); 1254 } 1255 1256 static MLX5E_DEFINE_STATS_GRP(sw_rep, 0); 1257 static MLX5E_DEFINE_STATS_GRP(vport_rep, MLX5E_NDO_UPDATE_STATS); 1258 1259 /* The stats groups order is opposite to the update_stats() order calls */ 1260 static mlx5e_stats_grp_t mlx5e_rep_stats_grps[] = { 1261 &MLX5E_STATS_GRP(sw_rep), 1262 &MLX5E_STATS_GRP(vport_rep), 1263 }; 1264 1265 static unsigned int mlx5e_rep_stats_grps_num(struct mlx5e_priv *priv) 1266 { 1267 return ARRAY_SIZE(mlx5e_rep_stats_grps); 1268 } 1269 1270 /* The stats groups order is opposite to the update_stats() order calls */ 1271 static mlx5e_stats_grp_t mlx5e_ul_rep_stats_grps[] = { 1272 &MLX5E_STATS_GRP(sw), 1273 &MLX5E_STATS_GRP(qcnt), 1274 &MLX5E_STATS_GRP(vnic_env), 1275 &MLX5E_STATS_GRP(vport), 1276 &MLX5E_STATS_GRP(802_3), 1277 &MLX5E_STATS_GRP(2863), 1278 &MLX5E_STATS_GRP(2819), 1279 &MLX5E_STATS_GRP(phy), 1280 &MLX5E_STATS_GRP(eth_ext), 1281 &MLX5E_STATS_GRP(pcie), 1282 &MLX5E_STATS_GRP(per_prio), 1283 &MLX5E_STATS_GRP(pme), 1284 &MLX5E_STATS_GRP(channels), 1285 &MLX5E_STATS_GRP(per_port_buff_congest), 1286 #ifdef CONFIG_MLX5_EN_IPSEC 1287 &MLX5E_STATS_GRP(ipsec_sw), 1288 #endif 1289 &MLX5E_STATS_GRP(ptp), 1290 }; 1291 1292 static unsigned int mlx5e_ul_rep_stats_grps_num(struct mlx5e_priv *priv) 1293 { 1294 return ARRAY_SIZE(mlx5e_ul_rep_stats_grps); 1295 } 1296 1297 static const struct mlx5e_profile mlx5e_rep_profile = { 1298 .init = mlx5e_init_rep, 1299 .cleanup = mlx5e_cleanup_rep, 1300 .init_rx = mlx5e_init_rep_rx, 1301 .cleanup_rx = mlx5e_cleanup_rep_rx, 1302 .init_tx = mlx5e_init_rep_tx, 1303 .cleanup_tx = mlx5e_cleanup_rep_tx, 1304 .enable = mlx5e_rep_enable, 1305 .disable = mlx5e_rep_disable, 1306 .update_rx = mlx5e_update_rep_rx, 1307 .update_stats = mlx5e_stats_update_ndo_stats, 1308 .rx_handlers = &mlx5e_rx_handlers_rep, 1309 .max_tc = 1, 1310 .stats_grps = mlx5e_rep_stats_grps, 1311 .stats_grps_num = mlx5e_rep_stats_grps_num, 1312 .max_nch_limit = mlx5e_rep_max_nch_limit, 1313 }; 1314 1315 static const struct mlx5e_profile mlx5e_uplink_rep_profile = { 1316 .init = mlx5e_init_ul_rep, 1317 .cleanup = mlx5e_cleanup_rep, 1318 .init_rx = mlx5e_init_ul_rep_rx, 1319 .cleanup_rx = mlx5e_cleanup_ul_rep_rx, 1320 .init_tx = mlx5e_init_rep_tx, 1321 .cleanup_tx = mlx5e_cleanup_rep_tx, 1322 .enable = mlx5e_uplink_rep_enable, 1323 .disable = mlx5e_uplink_rep_disable, 1324 .update_rx = mlx5e_update_rep_rx, 1325 .update_stats = mlx5e_stats_update_ndo_stats, 1326 .update_carrier = mlx5e_update_carrier, 1327 .rx_handlers = &mlx5e_rx_handlers_rep, 1328 .max_tc = MLX5E_MAX_NUM_TC, 1329 .stats_grps = mlx5e_ul_rep_stats_grps, 1330 .stats_grps_num = mlx5e_ul_rep_stats_grps_num, 1331 }; 1332 1333 /* e-Switch vport representors */ 1334 static int 1335 mlx5e_vport_uplink_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep) 1336 { 1337 struct mlx5e_priv *priv = netdev_priv(mlx5_uplink_netdev_get(dev)); 1338 struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep); 1339 1340 rpriv->netdev = priv->netdev; 1341 return mlx5e_netdev_change_profile(priv, &mlx5e_uplink_rep_profile, 1342 rpriv); 1343 } 1344 1345 static void 1346 mlx5e_vport_uplink_rep_unload(struct mlx5e_rep_priv *rpriv) 1347 { 1348 struct net_device *netdev = rpriv->netdev; 1349 struct mlx5e_priv *priv; 1350 1351 priv = netdev_priv(netdev); 1352 1353 mlx5e_netdev_attach_nic_profile(priv); 1354 } 1355 1356 static int 1357 mlx5e_vport_vf_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep) 1358 { 1359 struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep); 1360 const struct mlx5e_profile *profile; 1361 struct devlink_port *dl_port; 1362 struct net_device *netdev; 1363 struct mlx5e_priv *priv; 1364 int err; 1365 1366 profile = &mlx5e_rep_profile; 1367 netdev = mlx5e_create_netdev(dev, profile); 1368 if (!netdev) { 1369 mlx5_core_warn(dev, 1370 "Failed to create representor netdev for vport %d\n", 1371 rep->vport); 1372 return -EINVAL; 1373 } 1374 1375 mlx5e_build_rep_netdev(netdev, dev); 1376 rpriv->netdev = netdev; 1377 1378 priv = netdev_priv(netdev); 1379 priv->profile = profile; 1380 priv->ppriv = rpriv; 1381 err = profile->init(dev, netdev); 1382 if (err) { 1383 netdev_warn(netdev, "rep profile init failed, %d\n", err); 1384 goto err_destroy_netdev; 1385 } 1386 1387 err = mlx5e_attach_netdev(netdev_priv(netdev)); 1388 if (err) { 1389 netdev_warn(netdev, 1390 "Failed to attach representor netdev for vport %d\n", 1391 rep->vport); 1392 goto err_cleanup_profile; 1393 } 1394 1395 dl_port = mlx5_esw_offloads_devlink_port(dev->priv.eswitch, 1396 rpriv->rep->vport); 1397 if (dl_port) 1398 SET_NETDEV_DEVLINK_PORT(netdev, dl_port); 1399 1400 err = register_netdev(netdev); 1401 if (err) { 1402 netdev_warn(netdev, 1403 "Failed to register representor netdev for vport %d\n", 1404 rep->vport); 1405 goto err_detach_netdev; 1406 } 1407 1408 return 0; 1409 1410 err_detach_netdev: 1411 mlx5e_detach_netdev(netdev_priv(netdev)); 1412 1413 err_cleanup_profile: 1414 priv->profile->cleanup(priv); 1415 1416 err_destroy_netdev: 1417 mlx5e_destroy_netdev(netdev_priv(netdev)); 1418 return err; 1419 } 1420 1421 static int 1422 mlx5e_vport_rep_load(struct mlx5_core_dev *dev, struct mlx5_eswitch_rep *rep) 1423 { 1424 struct mlx5e_rep_priv *rpriv; 1425 int err; 1426 1427 rpriv = kvzalloc(sizeof(*rpriv), GFP_KERNEL); 1428 if (!rpriv) 1429 return -ENOMEM; 1430 1431 /* rpriv->rep to be looked up when profile->init() is called */ 1432 rpriv->rep = rep; 1433 rep->rep_data[REP_ETH].priv = rpriv; 1434 INIT_LIST_HEAD(&rpriv->vport_sqs_list); 1435 1436 if (rep->vport == MLX5_VPORT_UPLINK) 1437 err = mlx5e_vport_uplink_rep_load(dev, rep); 1438 else 1439 err = mlx5e_vport_vf_rep_load(dev, rep); 1440 1441 if (err) 1442 kvfree(rpriv); 1443 1444 return err; 1445 } 1446 1447 static void 1448 mlx5e_vport_rep_unload(struct mlx5_eswitch_rep *rep) 1449 { 1450 struct mlx5e_rep_priv *rpriv = mlx5e_rep_to_rep_priv(rep); 1451 struct net_device *netdev = rpriv->netdev; 1452 struct mlx5e_priv *priv = netdev_priv(netdev); 1453 void *ppriv = priv->ppriv; 1454 1455 if (rep->vport == MLX5_VPORT_UPLINK) { 1456 mlx5e_vport_uplink_rep_unload(rpriv); 1457 goto free_ppriv; 1458 } 1459 1460 unregister_netdev(netdev); 1461 mlx5e_detach_netdev(priv); 1462 priv->profile->cleanup(priv); 1463 mlx5e_destroy_netdev(priv); 1464 free_ppriv: 1465 kvfree(ppriv); /* mlx5e_rep_priv */ 1466 } 1467 1468 static void *mlx5e_vport_rep_get_proto_dev(struct mlx5_eswitch_rep *rep) 1469 { 1470 struct mlx5e_rep_priv *rpriv; 1471 1472 rpriv = mlx5e_rep_to_rep_priv(rep); 1473 1474 return rpriv->netdev; 1475 } 1476 1477 static void mlx5e_vport_rep_event_unpair(struct mlx5_eswitch_rep *rep) 1478 { 1479 struct mlx5e_rep_priv *rpriv; 1480 struct mlx5e_rep_sq *rep_sq; 1481 1482 rpriv = mlx5e_rep_to_rep_priv(rep); 1483 list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) { 1484 if (!rep_sq->send_to_vport_rule_peer) 1485 continue; 1486 mlx5_eswitch_del_send_to_vport_rule(rep_sq->send_to_vport_rule_peer); 1487 rep_sq->send_to_vport_rule_peer = NULL; 1488 } 1489 } 1490 1491 static int mlx5e_vport_rep_event_pair(struct mlx5_eswitch *esw, 1492 struct mlx5_eswitch_rep *rep, 1493 struct mlx5_eswitch *peer_esw) 1494 { 1495 struct mlx5_flow_handle *flow_rule; 1496 struct mlx5e_rep_priv *rpriv; 1497 struct mlx5e_rep_sq *rep_sq; 1498 1499 rpriv = mlx5e_rep_to_rep_priv(rep); 1500 list_for_each_entry(rep_sq, &rpriv->vport_sqs_list, list) { 1501 if (rep_sq->send_to_vport_rule_peer) 1502 continue; 1503 flow_rule = mlx5_eswitch_add_send_to_vport_rule(peer_esw, esw, rep, rep_sq->sqn); 1504 if (IS_ERR(flow_rule)) 1505 goto err_out; 1506 rep_sq->send_to_vport_rule_peer = flow_rule; 1507 } 1508 1509 return 0; 1510 err_out: 1511 mlx5e_vport_rep_event_unpair(rep); 1512 return PTR_ERR(flow_rule); 1513 } 1514 1515 static int mlx5e_vport_rep_event(struct mlx5_eswitch *esw, 1516 struct mlx5_eswitch_rep *rep, 1517 enum mlx5_switchdev_event event, 1518 void *data) 1519 { 1520 int err = 0; 1521 1522 if (event == MLX5_SWITCHDEV_EVENT_PAIR) 1523 err = mlx5e_vport_rep_event_pair(esw, rep, data); 1524 else if (event == MLX5_SWITCHDEV_EVENT_UNPAIR) 1525 mlx5e_vport_rep_event_unpair(rep); 1526 1527 return err; 1528 } 1529 1530 static const struct mlx5_eswitch_rep_ops rep_ops = { 1531 .load = mlx5e_vport_rep_load, 1532 .unload = mlx5e_vport_rep_unload, 1533 .get_proto_dev = mlx5e_vport_rep_get_proto_dev, 1534 .event = mlx5e_vport_rep_event, 1535 }; 1536 1537 static int mlx5e_rep_probe(struct auxiliary_device *adev, 1538 const struct auxiliary_device_id *id) 1539 { 1540 struct mlx5_adev *edev = container_of(adev, struct mlx5_adev, adev); 1541 struct mlx5_core_dev *mdev = edev->mdev; 1542 struct mlx5_eswitch *esw; 1543 1544 esw = mdev->priv.eswitch; 1545 mlx5_eswitch_register_vport_reps(esw, &rep_ops, REP_ETH); 1546 return 0; 1547 } 1548 1549 static void mlx5e_rep_remove(struct auxiliary_device *adev) 1550 { 1551 struct mlx5_adev *vdev = container_of(adev, struct mlx5_adev, adev); 1552 struct mlx5_core_dev *mdev = vdev->mdev; 1553 struct mlx5_eswitch *esw; 1554 1555 esw = mdev->priv.eswitch; 1556 mlx5_eswitch_unregister_vport_reps(esw, REP_ETH); 1557 } 1558 1559 static const struct auxiliary_device_id mlx5e_rep_id_table[] = { 1560 { .name = MLX5_ADEV_NAME ".eth-rep", }, 1561 {}, 1562 }; 1563 1564 MODULE_DEVICE_TABLE(auxiliary, mlx5e_rep_id_table); 1565 1566 static struct auxiliary_driver mlx5e_rep_driver = { 1567 .name = "eth-rep", 1568 .probe = mlx5e_rep_probe, 1569 .remove = mlx5e_rep_remove, 1570 .id_table = mlx5e_rep_id_table, 1571 }; 1572 1573 int mlx5e_rep_init(void) 1574 { 1575 return auxiliary_driver_register(&mlx5e_rep_driver); 1576 } 1577 1578 void mlx5e_rep_cleanup(void) 1579 { 1580 auxiliary_driver_unregister(&mlx5e_rep_driver); 1581 } 1582