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