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
  27 static void ef100_update_name(struct efx_nic *efx)
  28 {
  29         strcpy(efx->name, efx->net_dev->name);
  30 }
  31
  32 static int ef100_alloc_vis(struct efx_nic *efx, unsigned int *allocated_vis)
  33 {
  34         /* EF100 uses a single TXQ per channel, as all checksum offloading
  35          * is configured in the TX descriptor, and there is no TX Pacer for
  36          * HIGHPRI queues.
  37          */
  38         unsigned int tx_vis = efx->n_tx_channels + efx->n_extra_tx_channels;
  39         unsigned int rx_vis = efx->n_rx_channels;
  40         unsigned int min_vis, max_vis;
  41
  42         EFX_WARN_ON_PARANOID(efx->tx_queues_per_channel != 1);
  43
  44         tx_vis += efx->n_xdp_channels * efx->xdp_tx_per_channel;
  45
  46         max_vis = max(rx_vis, tx_vis);
  47         /* Currently don't handle resource starvation and only accept
  48          * our maximum needs and no less.
  49          */
  50         min_vis = max_vis;
  51
  52         return efx_mcdi_alloc_vis(efx, min_vis, max_vis,
  53                                   NULL, allocated_vis);
  54 }
  55
  56 static int ef100_remap_bar(struct efx_nic *efx, int max_vis)
  57 {
  58         unsigned int uc_mem_map_size;
  59         void __iomem *membase;
  60
  61         efx->max_vis = max_vis;
  62         uc_mem_map_size = PAGE_ALIGN(max_vis * efx->vi_stride);
  63
  64         /* Extend the original UC mapping of the memory BAR */
  65         membase = ioremap(efx->membase_phys, uc_mem_map_size);
  66         if (!membase) {
  67                 netif_err(efx, probe, efx->net_dev,
  68                           "could not extend memory BAR to %x\n",
  69                           uc_mem_map_size);
  70                 return -ENOMEM;
  71         }
  72         iounmap(efx->membase);
  73         efx->membase = membase;
  74         return 0;
  75 }
  76
  77 /* Context: process, rtnl_lock() held.
  78  * Note that the kernel will ignore our return code; this method
  79  * should really be a void.
  80  */
  81 static int ef100_net_stop(struct net_device *net_dev)
  82 {
  83         struct efx_nic *efx = efx_netdev_priv(net_dev);
  84
  85         netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",
  86                   raw_smp_processor_id());
  87
  88         efx_detach_reps(efx);
  89         netif_stop_queue(net_dev);
  90         efx_stop_all(efx);
  91         efx_mcdi_mac_fini_stats(efx);
  92         efx_disable_interrupts(efx);
  93         efx_clear_interrupt_affinity(efx);
  94         efx_nic_fini_interrupt(efx);
  95         efx_remove_filters(efx);
  96         efx_fini_napi(efx);
  97         efx_remove_channels(efx);
  98         efx_mcdi_free_vis(efx);
  99         efx_remove_interrupts(efx);
 100
 101         efx->state = STATE_NET_DOWN;
 102
 103         return 0;
 104 }
 105
 106 /* Context: process, rtnl_lock() held. */
 107 static int ef100_net_open(struct net_device *net_dev)
 108 {
 109         struct efx_nic *efx = efx_netdev_priv(net_dev);
 110         unsigned int allocated_vis;
 111         int rc;
 112
 113         ef100_update_name(efx);
 114         netif_dbg(efx, ifup, net_dev, "opening device on CPU %d\n",
 115                   raw_smp_processor_id());
 116
 117         rc = efx_check_disabled(efx);
 118         if (rc)
 119                 goto fail;
 120
 121         rc = efx_probe_interrupts(efx);
 122         if (rc)
 123                 goto fail;
 124
 125         rc = efx_set_channels(efx);
 126         if (rc)
 127                 goto fail;
 128
 129         rc = efx_mcdi_free_vis(efx);
 130         if (rc)
 131                 goto fail;
 132
 133         rc = ef100_alloc_vis(efx, &allocated_vis);
 134         if (rc)
 135                 goto fail;
 136
 137         rc = efx_probe_channels(efx);
 138         if (rc)
 139                 return rc;
 140
 141         rc = ef100_remap_bar(efx, allocated_vis);
 142         if (rc)
 143                 goto fail;
 144
 145         efx_init_napi(efx);
 146
 147         rc = efx_probe_filters(efx);
 148         if (rc)
 149                 goto fail;
 150
 151         rc = efx_nic_init_interrupt(efx);
 152         if (rc)
 153                 goto fail;
 154         efx_set_interrupt_affinity(efx);
 155
 156         rc = efx_enable_interrupts(efx);
 157         if (rc)
 158                 goto fail;
 159
 160         /* in case the MC rebooted while we were stopped, consume the change
 161          * to the warm reboot count
 162          */
 163         (void) efx_mcdi_poll_reboot(efx);
 164
 165         rc = efx_mcdi_mac_init_stats(efx);
 166         if (rc)
 167                 goto fail;
 168
 169         efx_start_all(efx);
 170
 171         /* Link state detection is normally event-driven; we have
 172          * to poll now because we could have missed a change
 173          */
 174         mutex_lock(&efx->mac_lock);
 175         if (efx_mcdi_phy_poll(efx))
 176                 efx_link_status_changed(efx);
 177         mutex_unlock(&efx->mac_lock);
 178
 179         efx->state = STATE_NET_UP;
 180         if (netif_running(efx->net_dev))
 181                 efx_attach_reps(efx);
 182
 183         return 0;
 184
 185 fail:
 186         ef100_net_stop(net_dev);
 187         return rc;
 188 }
 189
 190 /* Initiate a packet transmission.  We use one channel per CPU
 191  * (sharing when we have more CPUs than channels).
 192  *
 193  * Context: non-blocking.
 194  * Note that returning anything other than NETDEV_TX_OK will cause the
 195  * OS to free the skb.
 196  */
 197 static netdev_tx_t ef100_hard_start_xmit(struct sk_buff *skb,
 198                                          struct net_device *net_dev)
 199 {
 200         struct efx_nic *efx = efx_netdev_priv(net_dev);
 201
 202         return __ef100_hard_start_xmit(skb, efx, net_dev, NULL);
 203 }
 204
 205 netdev_tx_t __ef100_hard_start_xmit(struct sk_buff *skb,
 206                                     struct efx_nic *efx,
 207                                     struct net_device *net_dev,
 208                                     struct efx_rep *efv)
 209 {
 210         struct efx_tx_queue *tx_queue;
 211         struct efx_channel *channel;
 212         int rc;
 213
 214         channel = efx_get_tx_channel(efx, skb_get_queue_mapping(skb));
 215         netif_vdbg(efx, tx_queued, efx->net_dev,
 216                    "%s len %d data %d channel %d\n", __func__,
 217                    skb->len, skb->data_len, channel->channel);
 218         if (!efx->n_channels || !efx->n_tx_channels || !channel) {
 219                 netif_stop_queue(net_dev);
 220                 goto err;
 221         }
 222
 223         tx_queue = &channel->tx_queue[0];
 224         rc = __ef100_enqueue_skb(tx_queue, skb, efv);
 225         if (rc == 0)
 226                 return NETDEV_TX_OK;
 227
 228 err:
 229         net_dev->stats.tx_dropped++;
 230         return NETDEV_TX_OK;
 231 }
 232
 233 static const struct net_device_ops ef100_netdev_ops = {
 234         .ndo_open               = ef100_net_open,
 235         .ndo_stop               = ef100_net_stop,
 236         .ndo_start_xmit         = ef100_hard_start_xmit,
 237         .ndo_tx_timeout         = efx_watchdog,
 238         .ndo_get_stats64        = efx_net_stats,
 239         .ndo_change_mtu         = efx_change_mtu,
 240         .ndo_validate_addr      = eth_validate_addr,
 241         .ndo_set_mac_address    = efx_set_mac_address,
 242         .ndo_set_rx_mode        = efx_set_rx_mode, /* Lookout */
 243         .ndo_set_features       = efx_set_features,
 244         .ndo_get_phys_port_id   = efx_get_phys_port_id,
 245         .ndo_get_phys_port_name = efx_get_phys_port_name,
 246 #ifdef CONFIG_RFS_ACCEL
 247         .ndo_rx_flow_steer      = efx_filter_rfs,
 248 #endif
 249 };
 250
 251 /*      Netdev registration
 252  */
 253 int ef100_netdev_event(struct notifier_block *this,
 254                        unsigned long event, void *ptr)
 255 {
 256         struct efx_nic *efx = container_of(this, struct efx_nic, netdev_notifier);
 257         struct net_device *net_dev = netdev_notifier_info_to_dev(ptr);
 258
 259         if (efx->net_dev == net_dev &&
 260             (event == NETDEV_CHANGENAME || event == NETDEV_REGISTER))
 261                 ef100_update_name(efx);
 262
 263         return NOTIFY_DONE;
 264 }
 265
 266 static int ef100_register_netdev(struct efx_nic *efx)
 267 {
 268         struct net_device *net_dev = efx->net_dev;
 269         int rc;
 270
 271         net_dev->watchdog_timeo = 5 * HZ;
 272         net_dev->irq = efx->pci_dev->irq;
 273         net_dev->netdev_ops = &ef100_netdev_ops;
 274         net_dev->min_mtu = EFX_MIN_MTU;
 275         net_dev->max_mtu = EFX_MAX_MTU;
 276         net_dev->ethtool_ops = &ef100_ethtool_ops;
 277
 278         rtnl_lock();
 279
 280         rc = dev_alloc_name(net_dev, net_dev->name);
 281         if (rc < 0)
 282                 goto fail_locked;
 283         ef100_update_name(efx);
 284
 285         rc = register_netdevice(net_dev);
 286         if (rc)
 287                 goto fail_locked;
 288
 289         /* Always start with carrier off; PHY events will detect the link */
 290         netif_carrier_off(net_dev);
 291
 292         efx->state = STATE_NET_DOWN;
 293         rtnl_unlock();
 294         efx_init_mcdi_logging(efx);
 295
 296         return 0;
 297
 298 fail_locked:
 299         rtnl_unlock();
 300         netif_err(efx, drv, efx->net_dev, "could not register net dev\n");
 301         return rc;
 302 }
 303
 304 static void ef100_unregister_netdev(struct efx_nic *efx)
 305 {
 306         if (efx_dev_registered(efx)) {
 307                 efx_fini_mcdi_logging(efx);
 308                 efx->state = STATE_PROBED;
 309                 unregister_netdev(efx->net_dev);
 310         }
 311 }
 312
 313 void ef100_remove_netdev(struct efx_probe_data *probe_data)
 314 {
 315         struct efx_nic *efx = &probe_data->efx;
 316
 317         if (!efx->net_dev)
 318                 return;
 319
 320         rtnl_lock();
 321         dev_close(efx->net_dev);
 322         rtnl_unlock();
 323
 324         unregister_netdevice_notifier(&efx->netdev_notifier);
 325 #if defined(CONFIG_SFC_SRIOV)
 326         if (!efx->type->is_vf)
 327                 efx_ef100_pci_sriov_disable(efx, true);
 328 #endif
 329
 330         ef100_unregister_netdev(efx);
 331
 332 #ifdef CONFIG_SFC_SRIOV
 333         efx_fini_tc(efx);
 334 #endif
 335
 336         down_write(&efx->filter_sem);
 337         efx_mcdi_filter_table_remove(efx);
 338         up_write(&efx->filter_sem);
 339         efx_fini_channels(efx);
 340         kfree(efx->phy_data);
 341         efx->phy_data = NULL;
 342
 343         free_netdev(efx->net_dev);
 344         efx->net_dev = NULL;
 345         efx->state = STATE_PROBED;
 346 }
 347
 348 int ef100_probe_netdev(struct efx_probe_data *probe_data)
 349 {
 350         struct efx_nic *efx = &probe_data->efx;
 351         struct efx_probe_data **probe_ptr;
 352         struct net_device *net_dev;
 353         int rc;
 354
 355         if (efx->mcdi->fn_flags &
 356                         (1 << MC_CMD_DRV_ATTACH_EXT_OUT_FLAG_NO_ACTIVE_PORT)) {
 357                 pci_info(efx->pci_dev, "No network port on this PCI function");
 358                 return 0;
 359         }
 360
 361         /* Allocate and initialise a struct net_device */
 362         net_dev = alloc_etherdev_mq(sizeof(probe_data), EFX_MAX_CORE_TX_QUEUES);
 363         if (!net_dev)
 364                 return -ENOMEM;
 365         probe_ptr = netdev_priv(net_dev);
 366         *probe_ptr = probe_data;
 367         efx->net_dev = net_dev;
 368         SET_NETDEV_DEV(net_dev, &efx->pci_dev->dev);
 369
 370         net_dev->features |= efx->type->offload_features;
 371         net_dev->hw_features |= efx->type->offload_features;
 372         net_dev->hw_enc_features |= efx->type->offload_features;
 373         net_dev->vlan_features |= NETIF_F_HW_CSUM | NETIF_F_SG |
 374                                   NETIF_F_HIGHDMA | NETIF_F_ALL_TSO;
 375         netif_set_tso_max_segs(net_dev,
 376                                ESE_EF100_DP_GZ_TSO_MAX_HDR_NUM_SEGS_DEFAULT);
 377         efx->mdio.dev = net_dev;
 378
 379         rc = efx_ef100_init_datapath_caps(efx);
 380         if (rc < 0)
 381                 goto fail;
 382
 383         rc = ef100_phy_probe(efx);
 384         if (rc)
 385                 goto fail;
 386
 387         rc = efx_init_channels(efx);
 388         if (rc)
 389                 goto fail;
 390
 391         down_write(&efx->filter_sem);
 392         rc = ef100_filter_table_probe(efx);
 393         up_write(&efx->filter_sem);
 394         if (rc)
 395                 goto fail;
 396
 397         netdev_rss_key_fill(efx->rss_context.rx_hash_key,
 398                             sizeof(efx->rss_context.rx_hash_key));
 399
 400         /* Don't fail init if RSS setup doesn't work. */
 401         efx_mcdi_push_default_indir_table(efx, efx->n_rx_channels);
 402
 403         rc = ef100_register_netdev(efx);
 404         if (rc)
 405                 goto fail;
 406
 407         if (!efx->type->is_vf) {
 408                 rc = ef100_probe_netdev_pf(efx);
 409                 if (rc)
 410                         goto fail;
 411         }
 412
 413         efx->netdev_notifier.notifier_call = ef100_netdev_event;
 414         rc = register_netdevice_notifier(&efx->netdev_notifier);
 415         if (rc) {
 416                 netif_err(efx, probe, efx->net_dev,
 417                           "Failed to register netdevice notifier, rc=%d\n", rc);
 418                 goto fail;
 419         }
 420
 421 fail:
 422         return rc;
 423 }