drivers/net/ethernet/sfc/ef100_netdev.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /****************************************************************************
   3  * Driver for Solarflare network controllers and boards
   4  * Copyright 2018 Solarflare Communications Inc.
   5  * Copyright 2019-2020 Xilinx Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published
   9  * by the Free Software Foundation, incorporated herein by reference.
  10  */
  11 #include "net_driver.h"
  12 #include "mcdi_port_common.h"
  13 #include "mcdi_functions.h"
  14 #include "efx_common.h"
  15 #include "efx_channels.h"
  16 #include "tx_common.h"
  17 #include "ef100_netdev.h"
  18 #include "ef100_ethtool.h"
  19 #include "nic_common.h"
  20 #include "ef100_nic.h"
  21 #include "ef100_tx.h"
  22 #include "ef100_regs.h"
  23 #include "mcdi_filters.h"
  24 #include "rx_common.h"
  25 #include "ef100_sriov.h"
  26 #include "tc_bindings.h"
  27 #include "tc_encap_actions.h"
  28 #include "efx_devlink.h"
  29
  30 static void ef100_update_name(struct efx_nic *efx)
  31 {
  32         strcpy(efx->name, efx->net_dev->name);
  33 }
  34
  35 static int ef100_alloc_vis(struct efx_nic *efx, unsigned int *allocated_vis)
  36 {
  37         /* EF100 uses a single TXQ per channel, as all checksum offloading
  38          * is configured in the TX descriptor, and there is no TX Pacer for
  39          * HIGHPRI queues.
  40          */
  41         unsigned int tx_vis = efx->n_tx_channels + efx->n_extra_tx_channels;
  42         unsigned int rx_vis = efx->n_rx_channels;
  43         unsigned int min_vis, max_vis;
  44         int rc;
  45
  46         EFX_WARN_ON_PARANOID(efx->tx_queues_per_channel != 1);
  47
  48         tx_vis += efx->n_xdp_channels * efx->xdp_tx_per_channel;
  49
  50         max_vis = max(rx_vis, tx_vis);
  51         /* We require at least a single complete TX channel worth of queues. */
  52         min_vis = efx->tx_queues_per_channel;
  53
  54         rc = efx_mcdi_alloc_vis(efx, min_vis, max_vis,
  55                                 NULL, allocated_vis);
  56
  57         /* We retry allocating VIs by reallocating channels when we have not
  58          * been able to allocate the maximum VIs.
  59          */
  60         if (!rc && *allocated_vis < max_vis)
  61                 rc = -EAGAIN;
  62
  63         return rc;
  64 }
  65
  66 static int ef100_remap_bar(struct efx_nic *efx, int max_vis)
  67 {
  68         unsigned int uc_mem_map_size;
  69         void __iomem *membase;
  70
  71         efx->max_vis = max_vis;
  72         uc_mem_map_size = PAGE_ALIGN(max_vis * efx->vi_stride);
  73
  74         /* Extend the original UC mapping of the memory BAR */
  75         membase = ioremap(efx->membase_phys, uc_mem_map_size);
  76         if (!membase) {
  77                 netif_err(efx, probe, efx->net_dev,
  78                           "could not extend memory BAR to %x\n",
  79                           uc_mem_map_size);
  80                 return -ENOMEM;
  81         }
  82         iounmap(efx->membase);
  83         efx->membase = membase;
  84         return 0;
  85 }
  86
  87 /* Context: process, rtnl_lock() held.
  88  * Note that the kernel will ignore our return code; this method
  89  * should really be a void.
  90  */
  91 static int ef100_net_stop(struct net_device *net_dev)
  92 {
  93         struct efx_nic *efx = efx_netdev_priv(net_dev);
  94
  95         netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",
  96                   raw_smp_processor_id());
  97
  98         efx_detach_reps(efx);
  99         netif_stop_queue(net_dev);
 100         efx_stop_all(efx);
 101         efx_mcdi_mac_fini_stats(efx);
 102         efx_disable_interrupts(efx);
 103         efx_clear_interrupt_affinity(efx);
 104         efx_nic_fini_interrupt(efx);
 105         efx_remove_filters(efx);
 106         efx_fini_napi(efx);
 107         efx_remove_channels(efx);
 108         efx_mcdi_free_vis(efx);
 109         efx_remove_interrupts(efx);
 110
 111         efx->state = STATE_NET_DOWN;
 112
 113         return 0;
 114 }
 115
 116 /* Context: process, rtnl_lock() held. */
 117 static int ef100_net_open(struct net_device *net_dev)
 118 {
 119         struct efx_nic *efx = efx_netdev_priv(net_dev);
 120         unsigned int allocated_vis;
 121         int rc;
 122
 123         ef100_update_name(efx);
 124         netif_dbg(efx, ifup, net_dev, "opening device on CPU %d\n",
 125                   raw_smp_processor_id());
 126
 127         rc = efx_check_disabled(efx);
 128         if (rc)
 129                 goto fail;
 130
 131         rc = efx_probe_interrupts(efx);
 132         if (rc)
 133                 goto fail;
 134
 135         rc = efx_set_channels(efx);
 136         if (rc)
 137                 goto fail;
 138
 139         rc = efx_mcdi_free_vis(efx);
 140         if (rc)
 141                 goto fail;
 142
 143         rc = ef100_alloc_vis(efx, &allocated_vis);
 144         if (rc && rc != -EAGAIN)
 145                 goto fail;
 146
 147         /* Try one more time but with the maximum number of channels
 148          * equal to the allocated VIs, which would more likely succeed.
 149          */
 150         if (rc == -EAGAIN) {
 151                 rc = efx_mcdi_free_vis(efx);
 152                 if (rc)
 153                         goto fail;
 154
 155                 efx_remove_interrupts(efx);
 156                 efx->max_channels = allocated_vis;
 157
 158                 rc = efx_probe_interrupts(efx);
 159                 if (rc)
 160                         goto fail;
 161
 162                 rc = efx_set_channels(efx);
 163                 if (rc)
 164                         goto fail;
 165
 166                 rc = ef100_alloc_vis(efx, &allocated_vis);
 167                 if (rc && rc != -EAGAIN)
 168                         goto fail;
 169
 170                 /* It should be very unlikely that we failed here again, but in
 171                  * such a case we return ENOSPC.
 172                  */
 173                 if (rc == -EAGAIN) {
 174                         rc = -ENOSPC;
 175                         goto fail;
 176                 }
 177         }
 178
 179         rc = efx_probe_channels(efx);
 180         if (rc)
 181                 return rc;
 182
 183         rc = ef100_remap_bar(efx, allocated_vis);
 184         if (rc)
 185                 goto fail;
 186
 187         efx_init_napi(efx);
 188
 189         rc = efx_probe_filters(efx);
 190         if (rc)
 191                 goto fail;
 192
 193         rc = efx_nic_init_interrupt(efx);
 194         if (rc)
 195                 goto fail;
 196         efx_set_interrupt_affinity(efx);
 197
 198         rc = efx_enable_interrupts(efx);
 199         if (rc)
 200                 goto fail;
 201
 202         /* in case the MC rebooted while we were stopped, consume the change
 203          * to the warm reboot count
 204          */
 205         (void) efx_mcdi_poll_reboot(efx);
 206
 207         rc = efx_mcdi_mac_init_stats(efx);
 208         if (rc)
 209                 goto fail;
 210
 211         efx_start_all(efx);
 212
 213         /* Link state detection is normally event-driven; we have
 214          * to poll now because we could have missed a change
 215          */
 216         mutex_lock(&efx->mac_lock);
 217         if (efx_mcdi_phy_poll(efx))
 218                 efx_link_status_changed(efx);
 219         mutex_unlock(&efx->mac_lock);
 220
 221         efx->state = STATE_NET_UP;
 222         if (netif_running(efx->net_dev))
 223                 efx_attach_reps(efx);
 224
 225         return 0;
 226
 227 fail:
 228         ef100_net_stop(net_dev);
 229         return rc;
 230 }
 231
 232 /* Initiate a packet transmission.  We use one channel per CPU
 233  * (sharing when we have more CPUs than channels).
 234  *
 235  * Context: non-blocking.
 236  * Note that returning anything other than NETDEV_TX_OK will cause the
 237  * OS to free the skb.
 238  */
 239 static netdev_tx_t ef100_hard_start_xmit(struct sk_buff *skb,
 240                                          struct net_device *net_dev)
 241 {
 242         struct efx_nic *efx = efx_netdev_priv(net_dev);
 243
 244         return __ef100_hard_start_xmit(skb, efx, net_dev, NULL);
 245 }
 246
 247 netdev_tx_t __ef100_hard_start_xmit(struct sk_buff *skb,
 248                                     struct efx_nic *efx,
 249                                     struct net_device *net_dev,
 250                                     struct efx_rep *efv)
 251 {
 252         struct efx_tx_queue *tx_queue;
 253         struct efx_channel *channel;
 254         int rc;
 255
 256         channel = efx_get_tx_channel(efx, skb_get_queue_mapping(skb));
 257         netif_vdbg(efx, tx_queued, efx->net_dev,
 258                    "%s len %d data %d channel %d\n", __func__,
 259                    skb->len, skb->data_len, channel->channel);
 260         if (!efx->n_channels || !efx->n_tx_channels || !channel) {
 261                 netif_stop_queue(net_dev);
 262                 dev_kfree_skb_any(skb);
 263                 goto err;
 264         }
 265
 266         tx_queue = &channel->tx_queue[0];
 267         rc = __ef100_enqueue_skb(tx_queue, skb, efv);
 268         if (rc == 0)
 269                 return NETDEV_TX_OK;
 270
 271 err:
 272         net_dev->stats.tx_dropped++;
 273         return NETDEV_TX_OK;
 274 }
 275
 276 static const struct net_device_ops ef100_netdev_ops = {
 277         .ndo_open               = ef100_net_open,
 278         .ndo_stop               = ef100_net_stop,
 279         .ndo_start_xmit         = ef100_hard_start_xmit,
 280         .ndo_tx_timeout         = efx_watchdog,
 281         .ndo_get_stats64        = efx_net_stats,
 282         .ndo_change_mtu         = efx_change_mtu,
 283         .ndo_validate_addr      = eth_validate_addr,
 284         .ndo_set_mac_address    = efx_set_mac_address,
 285         .ndo_set_rx_mode        = efx_set_rx_mode, /* Lookout */
 286         .ndo_set_features       = efx_set_features,
 287         .ndo_get_phys_port_id   = efx_get_phys_port_id,
 288         .ndo_get_phys_port_name = efx_get_phys_port_name,
 289 #ifdef CONFIG_RFS_ACCEL
 290         .ndo_rx_flow_steer      = efx_filter_rfs,
 291 #endif
 292 #ifdef CONFIG_SFC_SRIOV
 293         .ndo_setup_tc           = efx_tc_setup,
 294 #endif
 295 };
 296
 297 /*      Netdev registration
 298  */
 299 int ef100_netdev_event(struct notifier_block *this,
 300                        unsigned long event, void *ptr)
 301 {
 302         struct efx_nic *efx = container_of(this, struct efx_nic, netdev_notifier);
 303         struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
 304         struct ef100_nic_data *nic_data = efx->nic_data;
 305         int err;
 306
 307         if (efx->net_dev == net_dev &&
 308             (event == NETDEV_CHANGENAME || event == NETDEV_REGISTER))
 309                 ef100_update_name(efx);
 310
 311         if (!nic_data->grp_mae)
 312                 return NOTIFY_DONE;
 313         err = efx_tc_netdev_event(efx, event, net_dev);
 314         if (err & NOTIFY_STOP_MASK)
 315                 return err;
 316
 317         return NOTIFY_DONE;
 318 }
 319
 320 static int ef100_netevent_event(struct notifier_block *this,
 321                                 unsigned long event, void *ptr)
 322 {
 323         struct efx_nic *efx = container_of(this, struct efx_nic, netevent_notifier);
 324         struct ef100_nic_data *nic_data = efx->nic_data;
 325         int err;
 326
 327         if (!nic_data->grp_mae)
 328                 return NOTIFY_DONE;
 329         err = efx_tc_netevent_event(efx, event, ptr);
 330         if (err & NOTIFY_STOP_MASK)
 331                 return err;
 332
 333         return NOTIFY_DONE;
 334 };
 335
 336 static int ef100_register_netdev(struct efx_nic *efx)
 337 {
 338         struct net_device *net_dev = efx->net_dev;
 339         int rc;
 340
 341         net_dev->watchdog_timeo = 5 * HZ;
 342         net_dev->irq = efx->pci_dev->irq;
 343         net_dev->netdev_ops = &ef100_netdev_ops;
 344         net_dev->min_mtu = EFX_MIN_MTU;
 345         net_dev->max_mtu = EFX_MAX_MTU;
 346         net_dev->ethtool_ops = &ef100_ethtool_ops;
 347
 348         rtnl_lock();
 349
 350         rc = dev_alloc_name(net_dev, net_dev->name);
 351         if (rc < 0)
 352                 goto fail_locked;
 353         ef100_update_name(efx);
 354
 355         rc = register_netdevice(net_dev);
 356         if (rc)
 357                 goto fail_locked;
 358
 359         /* Always start with carrier off; PHY events will detect the link */
 360         netif_carrier_off(net_dev);
 361
 362         efx->state = STATE_NET_DOWN;
 363         rtnl_unlock();
 364         efx_init_mcdi_logging(efx);
 365
 366         return 0;
 367
 368 fail_locked:
 369         rtnl_unlock();
 370         netif_err(efx, drv, efx->net_dev, "could not register net dev\n");
 371         return rc;
 372 }
 373
 374 static void ef100_unregister_netdev(struct efx_nic *efx)
 375 {
 376         if (efx_dev_registered(efx)) {
 377                 efx_fini_mcdi_logging(efx);
 378                 efx->state = STATE_PROBED;
 379                 unregister_netdev(efx->net_dev);
 380         }
 381 }
 382
 383 void ef100_remove_netdev(struct efx_probe_data *probe_data)
 384 {
 385         struct efx_nic *efx = &probe_data->efx;
 386
 387         if (!efx->net_dev)
 388                 return;
 389
 390         rtnl_lock();
 391         dev_close(efx->net_dev);
 392         rtnl_unlock();
 393
 394         unregister_netdevice_notifier(&efx->netdev_notifier);
 395         unregister_netevent_notifier(&efx->netevent_notifier);
 396 #if defined(CONFIG_SFC_SRIOV)
 397         if (!efx->type->is_vf)
 398                 efx_ef100_pci_sriov_disable(efx, true);
 399 #endif
 400
 401         efx_fini_devlink_lock(efx);
 402         ef100_unregister_netdev(efx);
 403
 404 #ifdef CONFIG_SFC_SRIOV
 405         ef100_pf_unset_devlink_port(efx);
 406         efx_fini_tc(efx);
 407 #endif
 408
 409         down_write(&efx->filter_sem);
 410         efx_mcdi_filter_table_remove(efx);
 411         up_write(&efx->filter_sem);
 412         efx_fini_channels(efx);
 413         kfree(efx->phy_data);
 414         efx->phy_data = NULL;
 415
 416         efx_fini_devlink_and_unlock(efx);
 417
 418         free_netdev(efx->net_dev);
 419         efx->net_dev = NULL;
 420         efx->state = STATE_PROBED;
 421 }
 422
 423 int ef100_probe_netdev(struct efx_probe_data *probe_data)
 424 {
 425         struct efx_nic *efx = &probe_data->efx;
 426         struct efx_probe_data **probe_ptr;
 427         struct ef100_nic_data *nic_data;
 428         struct net_device *net_dev;
 429         int rc;
 430
 431         if (efx->mcdi->fn_flags &
 432                         (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_NO_ACTIVE_PORT)) {
 433                 pci_info(efx->pci_dev, "No network port on this PCI function");
 434                 return 0;
 435         }
 436
 437         /* Allocate and initialise a struct net_device */
 438         net_dev = alloc_etherdev_mq(sizeof(probe_data), EFX_MAX_CORE_TX_QUEUES);
 439         if (!net_dev)
 440                 return -ENOMEM;
 441         probe_ptr = netdev_priv(net_dev);
 442         *probe_ptr = probe_data;
 443         efx->net_dev = net_dev;
 444         SET_NETDEV_DEV(net_dev, &efx->pci_dev->dev);
 445
 446         /* enable all supported features except rx-fcs and rx-all */
 447         net_dev->features |= efx->type->offload_features &
 448                              ~(NETIF_F_RXFCS | NETIF_F_RXALL);
 449         net_dev->hw_features |= efx->type->offload_features;
 450         net_dev->hw_enc_features |= efx->type->offload_features;
 451         net_dev->vlan_features |= NETIF_F_HW_CSUM | NETIF_F_SG |
 452                                   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO;
 453         netif_set_tso_max_segs(net_dev,
 454                                ESE_EF100_DP_GZ_TSO_MAX_HDR_NUM_SEGS_DEFAULT);
 455         efx->mdio.dev = net_dev;
 456
 457         rc = efx_ef100_init_datapath_caps(efx);
 458         if (rc < 0)
 459                 goto fail;
 460
 461         rc = ef100_phy_probe(efx);
 462         if (rc)
 463                 goto fail;
 464
 465         rc = efx_init_channels(efx);
 466         if (rc)
 467                 goto fail;
 468
 469         down_write(&efx->filter_sem);
 470         rc = ef100_filter_table_probe(efx);
 471         up_write(&efx->filter_sem);
 472         if (rc)
 473                 goto fail;
 474
 475         netdev_rss_key_fill(efx->rss_context.rx_hash_key,
 476                             sizeof(efx->rss_context.rx_hash_key));
 477
 478         /* Don't fail init if RSS setup doesn't work. */
 479         efx_mcdi_push_default_indir_table(efx, efx->n_rx_channels);
 480
 481         nic_data = efx->nic_data;
 482         rc = ef100_get_mac_address(efx, net_dev->perm_addr, CLIENT_HANDLE_SELF,
 483                                    efx->type->is_vf);
 484         if (rc)
 485                 return rc;
 486         /* Assign MAC address */
 487         eth_hw_addr_set(net_dev, net_dev->perm_addr);
 488         ether_addr_copy(nic_data->port_id, net_dev->perm_addr);
 489
 490         /* devlink creation, registration and lock */
 491         rc = efx_probe_devlink_and_lock(efx);
 492         if (rc)
 493                 pci_info(efx->pci_dev, "devlink registration failed");
 494
 495         rc = ef100_register_netdev(efx);
 496         if (rc)
 497                 goto fail;
 498
 499         if (!efx->type->is_vf) {
 500                 rc = ef100_probe_netdev_pf(efx);
 501                 if (rc)
 502                         goto fail;
 503 #ifdef CONFIG_SFC_SRIOV
 504                 ef100_pf_set_devlink_port(efx);
 505 #endif
 506         }
 507
 508         efx->netdev_notifier.notifier_call = ef100_netdev_event;
 509         rc = register_netdevice_notifier(&efx->netdev_notifier);
 510         if (rc) {
 511                 netif_err(efx, probe, efx->net_dev,
 512                           "Failed to register netdevice notifier, rc=%d\n", rc);
 513                 goto fail;
 514         }
 515
 516         efx->netevent_notifier.notifier_call = ef100_netevent_event;
 517         rc = register_netevent_notifier(&efx->netevent_notifier);
 518         if (rc) {
 519                 netif_err(efx, probe, efx->net_dev,
 520                           "Failed to register netevent notifier, rc=%d\n", rc);
 521                 goto fail;
 522         }
 523
 524         efx_probe_devlink_unlock(efx);
 525         return rc;
 526 fail:
 527 #ifdef CONFIG_SFC_SRIOV
 528         /* remove devlink port if does exist */
 529         ef100_pf_unset_devlink_port(efx);
 530 #endif
 531         efx_probe_devlink_unlock(efx);
 532         return rc;
 533 }