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 } 534