1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */ 3 4 #include <linux/etherdevice.h> 5 #include <linux/io-64-nonatomic-hi-lo.h> 6 #include <linux/lockdep.h> 7 #include <net/dst_metadata.h> 8 #include <net/switchdev.h> 9 10 #include "nfpcore/nfp_cpp.h" 11 #include "nfpcore/nfp_nsp.h" 12 #include "nfp_app.h" 13 #include "nfp_main.h" 14 #include "nfp_net.h" 15 #include "nfp_net_ctrl.h" 16 #include "nfp_net_repr.h" 17 #include "nfp_net_sriov.h" 18 #include "nfp_port.h" 19 20 struct net_device * 21 nfp_repr_get_locked(struct nfp_app *app, struct nfp_reprs *set, unsigned int id) 22 { 23 return rcu_dereference_protected(set->reprs[id], 24 lockdep_is_held(&app->pf->lock)); 25 } 26 27 static void 28 nfp_repr_inc_tx_stats(struct net_device *netdev, unsigned int len, 29 int tx_status) 30 { 31 struct nfp_repr *repr = netdev_priv(netdev); 32 struct nfp_repr_pcpu_stats *stats; 33 34 if (unlikely(tx_status != NET_XMIT_SUCCESS && 35 tx_status != NET_XMIT_CN)) { 36 this_cpu_inc(repr->stats->tx_drops); 37 return; 38 } 39 40 stats = this_cpu_ptr(repr->stats); 41 u64_stats_update_begin(&stats->syncp); 42 stats->tx_packets++; 43 stats->tx_bytes += len; 44 u64_stats_update_end(&stats->syncp); 45 } 46 47 void nfp_repr_inc_rx_stats(struct net_device *netdev, unsigned int len) 48 { 49 struct nfp_repr *repr = netdev_priv(netdev); 50 struct nfp_repr_pcpu_stats *stats; 51 52 stats = this_cpu_ptr(repr->stats); 53 u64_stats_update_begin(&stats->syncp); 54 stats->rx_packets++; 55 stats->rx_bytes += len; 56 u64_stats_update_end(&stats->syncp); 57 } 58 59 static void 60 nfp_repr_phy_port_get_stats64(struct nfp_port *port, 61 struct rtnl_link_stats64 *stats) 62 { 63 u8 __iomem *mem = port->eth_stats; 64 65 stats->tx_packets = readq(mem + NFP_MAC_STATS_TX_FRAMES_TRANSMITTED_OK); 66 stats->tx_bytes = readq(mem + NFP_MAC_STATS_TX_OUT_OCTETS); 67 stats->tx_dropped = readq(mem + NFP_MAC_STATS_TX_OUT_ERRORS); 68 69 stats->rx_packets = readq(mem + NFP_MAC_STATS_RX_FRAMES_RECEIVED_OK); 70 stats->rx_bytes = readq(mem + NFP_MAC_STATS_RX_IN_OCTETS); 71 stats->rx_dropped = readq(mem + NFP_MAC_STATS_RX_IN_ERRORS); 72 } 73 74 static void 75 nfp_repr_vnic_get_stats64(struct nfp_port *port, 76 struct rtnl_link_stats64 *stats) 77 { 78 /* TX and RX stats are flipped as we are returning the stats as seen 79 * at the switch port corresponding to the VF. 80 */ 81 stats->tx_packets = readq(port->vnic + NFP_NET_CFG_STATS_RX_FRAMES); 82 stats->tx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_RX_OCTETS); 83 stats->tx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_RX_DISCARDS); 84 85 stats->rx_packets = readq(port->vnic + NFP_NET_CFG_STATS_TX_FRAMES); 86 stats->rx_bytes = readq(port->vnic + NFP_NET_CFG_STATS_TX_OCTETS); 87 stats->rx_dropped = readq(port->vnic + NFP_NET_CFG_STATS_TX_DISCARDS); 88 } 89 90 static void 91 nfp_repr_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats) 92 { 93 struct nfp_repr *repr = netdev_priv(netdev); 94 95 if (WARN_ON(!repr->port)) 96 return; 97 98 switch (repr->port->type) { 99 case NFP_PORT_PHYS_PORT: 100 if (!__nfp_port_get_eth_port(repr->port)) 101 break; 102 nfp_repr_phy_port_get_stats64(repr->port, stats); 103 break; 104 case NFP_PORT_PF_PORT: 105 case NFP_PORT_VF_PORT: 106 nfp_repr_vnic_get_stats64(repr->port, stats); 107 default: 108 break; 109 } 110 } 111 112 static bool 113 nfp_repr_has_offload_stats(const struct net_device *dev, int attr_id) 114 { 115 switch (attr_id) { 116 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 117 return true; 118 } 119 120 return false; 121 } 122 123 static int 124 nfp_repr_get_host_stats64(const struct net_device *netdev, 125 struct rtnl_link_stats64 *stats) 126 { 127 struct nfp_repr *repr = netdev_priv(netdev); 128 int i; 129 130 for_each_possible_cpu(i) { 131 u64 tbytes, tpkts, tdrops, rbytes, rpkts; 132 struct nfp_repr_pcpu_stats *repr_stats; 133 unsigned int start; 134 135 repr_stats = per_cpu_ptr(repr->stats, i); 136 do { 137 start = u64_stats_fetch_begin_irq(&repr_stats->syncp); 138 tbytes = repr_stats->tx_bytes; 139 tpkts = repr_stats->tx_packets; 140 tdrops = repr_stats->tx_drops; 141 rbytes = repr_stats->rx_bytes; 142 rpkts = repr_stats->rx_packets; 143 } while (u64_stats_fetch_retry_irq(&repr_stats->syncp, start)); 144 145 stats->tx_bytes += tbytes; 146 stats->tx_packets += tpkts; 147 stats->tx_dropped += tdrops; 148 stats->rx_bytes += rbytes; 149 stats->rx_packets += rpkts; 150 } 151 152 return 0; 153 } 154 155 static int 156 nfp_repr_get_offload_stats(int attr_id, const struct net_device *dev, 157 void *stats) 158 { 159 switch (attr_id) { 160 case IFLA_OFFLOAD_XSTATS_CPU_HIT: 161 return nfp_repr_get_host_stats64(dev, stats); 162 } 163 164 return -EINVAL; 165 } 166 167 static int nfp_repr_change_mtu(struct net_device *netdev, int new_mtu) 168 { 169 struct nfp_repr *repr = netdev_priv(netdev); 170 int err; 171 172 err = nfp_app_check_mtu(repr->app, netdev, new_mtu); 173 if (err) 174 return err; 175 176 err = nfp_app_repr_change_mtu(repr->app, netdev, new_mtu); 177 if (err) 178 return err; 179 180 netdev->mtu = new_mtu; 181 182 return 0; 183 } 184 185 static netdev_tx_t nfp_repr_xmit(struct sk_buff *skb, struct net_device *netdev) 186 { 187 struct nfp_repr *repr = netdev_priv(netdev); 188 unsigned int len = skb->len; 189 int ret; 190 191 skb_dst_drop(skb); 192 dst_hold((struct dst_entry *)repr->dst); 193 skb_dst_set(skb, (struct dst_entry *)repr->dst); 194 skb->dev = repr->dst->u.port_info.lower_dev; 195 196 ret = dev_queue_xmit(skb); 197 nfp_repr_inc_tx_stats(netdev, len, ret); 198 199 return ret; 200 } 201 202 static int nfp_repr_stop(struct net_device *netdev) 203 { 204 struct nfp_repr *repr = netdev_priv(netdev); 205 int err; 206 207 err = nfp_app_repr_stop(repr->app, repr); 208 if (err) 209 return err; 210 211 nfp_port_configure(netdev, false); 212 return 0; 213 } 214 215 static int nfp_repr_open(struct net_device *netdev) 216 { 217 struct nfp_repr *repr = netdev_priv(netdev); 218 int err; 219 220 err = nfp_port_configure(netdev, true); 221 if (err) 222 return err; 223 224 err = nfp_app_repr_open(repr->app, repr); 225 if (err) 226 goto err_port_disable; 227 228 return 0; 229 230 err_port_disable: 231 nfp_port_configure(netdev, false); 232 return err; 233 } 234 235 static netdev_features_t 236 nfp_repr_fix_features(struct net_device *netdev, netdev_features_t features) 237 { 238 struct nfp_repr *repr = netdev_priv(netdev); 239 netdev_features_t old_features = features; 240 netdev_features_t lower_features; 241 struct net_device *lower_dev; 242 243 lower_dev = repr->dst->u.port_info.lower_dev; 244 245 lower_features = lower_dev->features; 246 if (lower_features & (NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM)) 247 lower_features |= NETIF_F_HW_CSUM; 248 249 features = netdev_intersect_features(features, lower_features); 250 features |= old_features & (NETIF_F_SOFT_FEATURES | NETIF_F_HW_TC); 251 features |= NETIF_F_LLTX; 252 253 return features; 254 } 255 256 const struct net_device_ops nfp_repr_netdev_ops = { 257 .ndo_init = nfp_app_ndo_init, 258 .ndo_uninit = nfp_app_ndo_uninit, 259 .ndo_open = nfp_repr_open, 260 .ndo_stop = nfp_repr_stop, 261 .ndo_start_xmit = nfp_repr_xmit, 262 .ndo_change_mtu = nfp_repr_change_mtu, 263 .ndo_get_stats64 = nfp_repr_get_stats64, 264 .ndo_has_offload_stats = nfp_repr_has_offload_stats, 265 .ndo_get_offload_stats = nfp_repr_get_offload_stats, 266 .ndo_get_phys_port_name = nfp_port_get_phys_port_name, 267 .ndo_setup_tc = nfp_port_setup_tc, 268 .ndo_set_vf_mac = nfp_app_set_vf_mac, 269 .ndo_set_vf_vlan = nfp_app_set_vf_vlan, 270 .ndo_set_vf_spoofchk = nfp_app_set_vf_spoofchk, 271 .ndo_get_vf_config = nfp_app_get_vf_config, 272 .ndo_set_vf_link_state = nfp_app_set_vf_link_state, 273 .ndo_fix_features = nfp_repr_fix_features, 274 .ndo_set_features = nfp_port_set_features, 275 .ndo_set_mac_address = eth_mac_addr, 276 }; 277 278 void 279 nfp_repr_transfer_features(struct net_device *netdev, struct net_device *lower) 280 { 281 struct nfp_repr *repr = netdev_priv(netdev); 282 283 if (repr->dst->u.port_info.lower_dev != lower) 284 return; 285 286 netdev->gso_max_size = lower->gso_max_size; 287 netdev->gso_max_segs = lower->gso_max_segs; 288 289 netdev_update_features(netdev); 290 } 291 292 static void nfp_repr_clean(struct nfp_repr *repr) 293 { 294 unregister_netdev(repr->netdev); 295 nfp_app_repr_clean(repr->app, repr->netdev); 296 dst_release((struct dst_entry *)repr->dst); 297 nfp_port_free(repr->port); 298 } 299 300 static struct lock_class_key nfp_repr_netdev_xmit_lock_key; 301 static struct lock_class_key nfp_repr_netdev_addr_lock_key; 302 303 static void nfp_repr_set_lockdep_class_one(struct net_device *dev, 304 struct netdev_queue *txq, 305 void *_unused) 306 { 307 lockdep_set_class(&txq->_xmit_lock, &nfp_repr_netdev_xmit_lock_key); 308 } 309 310 static void nfp_repr_set_lockdep_class(struct net_device *dev) 311 { 312 lockdep_set_class(&dev->addr_list_lock, &nfp_repr_netdev_addr_lock_key); 313 netdev_for_each_tx_queue(dev, nfp_repr_set_lockdep_class_one, NULL); 314 } 315 316 int nfp_repr_init(struct nfp_app *app, struct net_device *netdev, 317 u32 cmsg_port_id, struct nfp_port *port, 318 struct net_device *pf_netdev) 319 { 320 struct nfp_repr *repr = netdev_priv(netdev); 321 struct nfp_net *nn = netdev_priv(pf_netdev); 322 u32 repr_cap = nn->tlv_caps.repr_cap; 323 int err; 324 325 nfp_repr_set_lockdep_class(netdev); 326 327 repr->port = port; 328 repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX, GFP_KERNEL); 329 if (!repr->dst) 330 return -ENOMEM; 331 repr->dst->u.port_info.port_id = cmsg_port_id; 332 repr->dst->u.port_info.lower_dev = pf_netdev; 333 334 netdev->netdev_ops = &nfp_repr_netdev_ops; 335 netdev->ethtool_ops = &nfp_port_ethtool_ops; 336 337 netdev->max_mtu = pf_netdev->max_mtu; 338 339 SWITCHDEV_SET_OPS(netdev, &nfp_port_switchdev_ops); 340 341 /* Set features the lower device can support with representors */ 342 if (repr_cap & NFP_NET_CFG_CTRL_LIVE_ADDR) 343 netdev->priv_flags |= IFF_LIVE_ADDR_CHANGE; 344 345 netdev->hw_features = NETIF_F_HIGHDMA; 346 if (repr_cap & NFP_NET_CFG_CTRL_RXCSUM_ANY) 347 netdev->hw_features |= NETIF_F_RXCSUM; 348 if (repr_cap & NFP_NET_CFG_CTRL_TXCSUM) 349 netdev->hw_features |= NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM; 350 if (repr_cap & NFP_NET_CFG_CTRL_GATHER) 351 netdev->hw_features |= NETIF_F_SG; 352 if ((repr_cap & NFP_NET_CFG_CTRL_LSO && nn->fw_ver.major > 2) || 353 repr_cap & NFP_NET_CFG_CTRL_LSO2) 354 netdev->hw_features |= NETIF_F_TSO | NETIF_F_TSO6; 355 if (repr_cap & NFP_NET_CFG_CTRL_RSS_ANY) 356 netdev->hw_features |= NETIF_F_RXHASH; 357 if (repr_cap & NFP_NET_CFG_CTRL_VXLAN) { 358 if (repr_cap & NFP_NET_CFG_CTRL_LSO) 359 netdev->hw_features |= NETIF_F_GSO_UDP_TUNNEL; 360 } 361 if (repr_cap & NFP_NET_CFG_CTRL_NVGRE) { 362 if (repr_cap & NFP_NET_CFG_CTRL_LSO) 363 netdev->hw_features |= NETIF_F_GSO_GRE; 364 } 365 if (repr_cap & (NFP_NET_CFG_CTRL_VXLAN | NFP_NET_CFG_CTRL_NVGRE)) 366 netdev->hw_enc_features = netdev->hw_features; 367 368 netdev->vlan_features = netdev->hw_features; 369 370 if (repr_cap & NFP_NET_CFG_CTRL_RXVLAN) 371 netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_RX; 372 if (repr_cap & NFP_NET_CFG_CTRL_TXVLAN) { 373 if (repr_cap & NFP_NET_CFG_CTRL_LSO2) 374 netdev_warn(netdev, "Device advertises both TSO2 and TXVLAN. Refusing to enable TXVLAN.\n"); 375 else 376 netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_TX; 377 } 378 if (repr_cap & NFP_NET_CFG_CTRL_CTAG_FILTER) 379 netdev->hw_features |= NETIF_F_HW_VLAN_CTAG_FILTER; 380 381 netdev->features = netdev->hw_features; 382 383 /* Advertise but disable TSO by default. */ 384 netdev->features &= ~(NETIF_F_TSO | NETIF_F_TSO6); 385 netdev->gso_max_segs = NFP_NET_LSO_MAX_SEGS; 386 387 netdev->priv_flags |= IFF_NO_QUEUE; 388 netdev->features |= NETIF_F_LLTX; 389 390 if (nfp_app_has_tc(app)) { 391 netdev->features |= NETIF_F_HW_TC; 392 netdev->hw_features |= NETIF_F_HW_TC; 393 } 394 395 err = nfp_app_repr_init(app, netdev); 396 if (err) 397 goto err_clean; 398 399 err = register_netdev(netdev); 400 if (err) 401 goto err_repr_clean; 402 403 return 0; 404 405 err_repr_clean: 406 nfp_app_repr_clean(app, netdev); 407 err_clean: 408 dst_release((struct dst_entry *)repr->dst); 409 return err; 410 } 411 412 static void __nfp_repr_free(struct nfp_repr *repr) 413 { 414 free_percpu(repr->stats); 415 free_netdev(repr->netdev); 416 } 417 418 void nfp_repr_free(struct net_device *netdev) 419 { 420 __nfp_repr_free(netdev_priv(netdev)); 421 } 422 423 struct net_device * 424 nfp_repr_alloc_mqs(struct nfp_app *app, unsigned int txqs, unsigned int rxqs) 425 { 426 struct net_device *netdev; 427 struct nfp_repr *repr; 428 429 netdev = alloc_etherdev_mqs(sizeof(*repr), txqs, rxqs); 430 if (!netdev) 431 return NULL; 432 433 netif_carrier_off(netdev); 434 435 repr = netdev_priv(netdev); 436 repr->netdev = netdev; 437 repr->app = app; 438 439 repr->stats = netdev_alloc_pcpu_stats(struct nfp_repr_pcpu_stats); 440 if (!repr->stats) 441 goto err_free_netdev; 442 443 return netdev; 444 445 err_free_netdev: 446 free_netdev(netdev); 447 return NULL; 448 } 449 450 void nfp_repr_clean_and_free(struct nfp_repr *repr) 451 { 452 nfp_info(repr->app->cpp, "Destroying Representor(%s)\n", 453 repr->netdev->name); 454 nfp_repr_clean(repr); 455 __nfp_repr_free(repr); 456 } 457 458 void nfp_reprs_clean_and_free(struct nfp_app *app, struct nfp_reprs *reprs) 459 { 460 struct net_device *netdev; 461 unsigned int i; 462 463 for (i = 0; i < reprs->num_reprs; i++) { 464 netdev = nfp_repr_get_locked(app, reprs, i); 465 if (netdev) 466 nfp_repr_clean_and_free(netdev_priv(netdev)); 467 } 468 469 kfree(reprs); 470 } 471 472 void 473 nfp_reprs_clean_and_free_by_type(struct nfp_app *app, enum nfp_repr_type type) 474 { 475 struct net_device *netdev; 476 struct nfp_reprs *reprs; 477 int i; 478 479 reprs = rcu_dereference_protected(app->reprs[type], 480 lockdep_is_held(&app->pf->lock)); 481 if (!reprs) 482 return; 483 484 /* Preclean must happen before we remove the reprs reference from the 485 * app below. 486 */ 487 for (i = 0; i < reprs->num_reprs; i++) { 488 netdev = nfp_repr_get_locked(app, reprs, i); 489 if (netdev) 490 nfp_app_repr_preclean(app, netdev); 491 } 492 493 reprs = nfp_app_reprs_set(app, type, NULL); 494 495 synchronize_rcu(); 496 nfp_reprs_clean_and_free(app, reprs); 497 } 498 499 struct nfp_reprs *nfp_reprs_alloc(unsigned int num_reprs) 500 { 501 struct nfp_reprs *reprs; 502 503 reprs = kzalloc(sizeof(*reprs) + 504 num_reprs * sizeof(struct net_device *), GFP_KERNEL); 505 if (!reprs) 506 return NULL; 507 reprs->num_reprs = num_reprs; 508 509 return reprs; 510 } 511 512 int nfp_reprs_resync_phys_ports(struct nfp_app *app) 513 { 514 struct net_device *netdev; 515 struct nfp_reprs *reprs; 516 struct nfp_repr *repr; 517 int i; 518 519 reprs = nfp_reprs_get_locked(app, NFP_REPR_TYPE_PHYS_PORT); 520 if (!reprs) 521 return 0; 522 523 for (i = 0; i < reprs->num_reprs; i++) { 524 netdev = nfp_repr_get_locked(app, reprs, i); 525 if (!netdev) 526 continue; 527 528 repr = netdev_priv(netdev); 529 if (repr->port->type != NFP_PORT_INVALID) 530 continue; 531 532 nfp_app_repr_preclean(app, netdev); 533 rtnl_lock(); 534 rcu_assign_pointer(reprs->reprs[i], NULL); 535 rtnl_unlock(); 536 synchronize_rcu(); 537 nfp_repr_clean(repr); 538 } 539 540 return 0; 541 } 542