Lines Matching refs:efx
17 #include "efx.h"
123 void efx_queue_reset_work(struct efx_nic *efx)
125 queue_work(reset_workqueue, &efx->reset_work);
128 void efx_flush_reset_workqueue(struct efx_nic *efx)
130 cancel_work_sync(&efx->reset_work);
141 /* We assume that efx->type->reconfigure_mac will always try to sync RX
144 void efx_mac_reconfigure(struct efx_nic *efx, bool mtu_only)
146 if (efx->type->reconfigure_mac) {
147 down_read(&efx->filter_sem);
148 efx->type->reconfigure_mac(efx, mtu_only);
149 up_read(&efx->filter_sem);
159 struct efx_nic *efx = container_of(data, struct efx_nic, mac_work);
161 mutex_lock(&efx->mac_lock);
162 if (efx->port_enabled)
163 efx_mac_reconfigure(efx, false);
164 mutex_unlock(&efx->mac_lock);
169 struct efx_nic *efx = netdev_priv(net_dev);
176 netif_err(efx, drv, efx->net_dev,
185 if (efx->type->set_mac_address) {
186 rc = efx->type->set_mac_address(efx);
194 mutex_lock(&efx->mac_lock);
195 efx_mac_reconfigure(efx, false);
196 mutex_unlock(&efx->mac_lock);
204 struct efx_nic *efx = netdev_priv(net_dev);
206 if (efx->port_enabled)
207 queue_work(efx->workqueue, &efx->mac_work);
213 struct efx_nic *efx = netdev_priv(net_dev);
218 rc = efx->type->filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);
241 void efx_link_status_changed(struct efx_nic *efx)
243 struct efx_link_state *link_state = &efx->link_state;
250 if (!netif_running(efx->net_dev))
253 if (link_state->up != netif_carrier_ok(efx->net_dev)) {
254 efx->n_link_state_changes++;
257 netif_carrier_on(efx->net_dev);
259 netif_carrier_off(efx->net_dev);
264 netif_info(efx, link, efx->net_dev,
267 efx->net_dev->mtu);
269 netif_info(efx, link, efx->net_dev, "link down\n");
272 unsigned int efx_xdp_max_mtu(struct efx_nic *efx)
278 efx->rx_prefix_size + efx->type->rx_buffer_padding +
279 efx->rx_ip_align + EFX_XDP_HEADROOM + EFX_XDP_TAILROOM;
287 struct efx_nic *efx = netdev_priv(net_dev);
290 rc = efx_check_disabled(efx);
294 if (rtnl_dereference(efx->xdp_prog) &&
295 new_mtu > efx_xdp_max_mtu(efx)) {
296 netif_err(efx, drv, efx->net_dev,
298 new_mtu, efx_xdp_max_mtu(efx));
302 netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);
304 efx_device_detach_sync(efx);
305 efx_stop_all(efx);
307 mutex_lock(&efx->mac_lock);
309 efx_mac_reconfigure(efx, true);
310 mutex_unlock(&efx->mac_lock);
312 efx_start_all(efx);
313 efx_device_attach_if_not_resetting(efx);
326 struct efx_nic *efx = container_of(data, struct efx_nic,
329 netif_vdbg(efx, timer, efx->net_dev,
332 BUG_ON(efx->type->monitor == NULL);
338 if (mutex_trylock(&efx->mac_lock)) {
339 if (efx->port_enabled && efx->type->monitor)
340 efx->type->monitor(efx);
341 mutex_unlock(&efx->mac_lock);
344 efx_start_monitor(efx);
347 void efx_start_monitor(struct efx_nic *efx)
349 if (efx->type->monitor)
350 queue_delayed_work(efx->workqueue, &efx->monitor_work,
364 static void efx_start_datapath(struct efx_nic *efx)
366 netdev_features_t old_features = efx->net_dev->features;
367 bool old_rx_scatter = efx->rx_scatter;
374 efx->rx_dma_len = (efx->rx_prefix_size +
375 EFX_MAX_FRAME_LEN(efx->net_dev->mtu) +
376 efx->type->rx_buffer_padding);
378 efx->rx_ip_align + efx->rx_dma_len + EFX_XDP_TAILROOM);
381 efx->rx_scatter = efx->type->always_rx_scatter;
382 efx->rx_buffer_order = 0;
383 } else if (efx->type->can_rx_scatter) {
389 efx->rx_scatter = true;
390 efx->rx_dma_len = EFX_RX_USR_BUF_SIZE;
391 efx->rx_buffer_order = 0;
393 efx->rx_scatter = false;
394 efx->rx_buffer_order = get_order(rx_buf_len);
397 efx_rx_config_page_split(efx);
398 if (efx->rx_buffer_order)
399 netif_dbg(efx, drv, efx->net_dev,
401 efx->rx_dma_len, efx->rx_buffer_order,
402 efx->rx_pages_per_batch);
404 netif_dbg(efx, drv, efx->net_dev,
406 efx->rx_dma_len, efx->rx_page_buf_step,
407 efx->rx_bufs_per_page, efx->rx_pages_per_batch);
412 efx->net_dev->hw_features |= efx->net_dev->features;
413 efx->net_dev->hw_features &= ~efx->fixed_features;
414 efx->net_dev->features |= efx->fixed_features;
415 if (efx->net_dev->features != old_features)
416 netdev_features_change(efx->net_dev);
419 if ((efx->rx_scatter != old_rx_scatter) &&
420 efx->type->filter_update_rx_scatter)
421 efx->type->filter_update_rx_scatter(efx);
430 efx->txq_stop_thresh = efx->txq_entries - efx_tx_max_skb_descs(efx);
431 efx->txq_wake_thresh = efx->txq_stop_thresh / 2;
434 efx_start_channels(efx);
436 efx_ptp_start_datapath(efx);
438 if (netif_device_present(efx->net_dev))
439 netif_tx_wake_all_queues(efx->net_dev);
442 static void efx_stop_datapath(struct efx_nic *efx)
444 EFX_ASSERT_RESET_SERIALISED(efx);
445 BUG_ON(efx->port_enabled);
447 efx_ptp_stop_datapath(efx);
449 efx_stop_channels(efx);
461 void efx_link_clear_advertising(struct efx_nic *efx)
463 bitmap_zero(efx->link_advertising, __ETHTOOL_LINK_MODE_MASK_NBITS);
464 efx->wanted_fc &= ~(EFX_FC_TX | EFX_FC_RX);
467 void efx_link_set_wanted_fc(struct efx_nic *efx, u8 wanted_fc)
469 efx->wanted_fc = wanted_fc;
470 if (efx->link_advertising[0]) {
472 efx->link_advertising[0] |= (ADVERTISED_Pause |
475 efx->link_advertising[0] &= ~(ADVERTISED_Pause |
478 efx->link_advertising[0] ^= ADVERTISED_Asym_Pause;
482 static void efx_start_port(struct efx_nic *efx)
484 netif_dbg(efx, ifup, efx->net_dev, "start port\n");
485 BUG_ON(efx->port_enabled);
487 mutex_lock(&efx->mac_lock);
488 efx->port_enabled = true;
491 efx_mac_reconfigure(efx, false);
493 mutex_unlock(&efx->mac_lock);
501 static void efx_stop_port(struct efx_nic *efx)
503 netif_dbg(efx, ifdown, efx->net_dev, "stop port\n");
505 EFX_ASSERT_RESET_SERIALISED(efx);
507 mutex_lock(&efx->mac_lock);
508 efx->port_enabled = false;
509 mutex_unlock(&efx->mac_lock);
512 netif_addr_lock_bh(efx->net_dev);
513 netif_addr_unlock_bh(efx->net_dev);
515 cancel_delayed_work_sync(&efx->monitor_work);
516 efx_selftest_async_cancel(efx);
517 cancel_work_sync(&efx->mac_work);
527 void efx_start_all(struct efx_nic *efx)
529 EFX_ASSERT_RESET_SERIALISED(efx);
530 BUG_ON(efx->state == STATE_DISABLED);
535 if (efx->port_enabled || !netif_running(efx->net_dev) ||
536 efx->reset_pending)
539 efx_start_port(efx);
540 efx_start_datapath(efx);
543 efx_start_monitor(efx);
545 efx_selftest_async_start(efx);
550 mutex_lock(&efx->mac_lock);
551 if (efx_mcdi_phy_poll(efx))
552 efx_link_status_changed(efx);
553 mutex_unlock(&efx->mac_lock);
555 if (efx->type->start_stats) {
556 efx->type->start_stats(efx);
557 efx->type->pull_stats(efx);
558 spin_lock_bh(&efx->stats_lock);
559 efx->type->update_stats(efx, NULL, NULL);
560 spin_unlock_bh(&efx->stats_lock);
569 void efx_stop_all(struct efx_nic *efx)
571 EFX_ASSERT_RESET_SERIALISED(efx);
574 if (!efx->port_enabled)
577 if (efx->type->update_stats) {
581 efx->type->pull_stats(efx);
582 spin_lock_bh(&efx->stats_lock);
583 efx->type->update_stats(efx, NULL, NULL);
584 spin_unlock_bh(&efx->stats_lock);
585 efx->type->stop_stats(efx);
588 efx_stop_port(efx);
594 WARN_ON(netif_running(efx->net_dev) &&
595 netif_device_present(efx->net_dev));
596 netif_tx_disable(efx->net_dev);
598 efx_stop_datapath(efx);
604 struct efx_nic *efx = netdev_priv(net_dev);
606 spin_lock_bh(&efx->stats_lock);
607 efx_nic_update_stats_atomic(efx, NULL, stats);
608 spin_unlock_bh(&efx->stats_lock);
618 int __efx_reconfigure_port(struct efx_nic *efx)
623 WARN_ON(!mutex_is_locked(&efx->mac_lock));
626 phy_mode = efx->phy_mode;
627 if (LOOPBACK_INTERNAL(efx))
628 efx->phy_mode |= PHY_MODE_TX_DISABLED;
630 efx->phy_mode &= ~PHY_MODE_TX_DISABLED;
632 if (efx->type->reconfigure_port)
633 rc = efx->type->reconfigure_port(efx);
636 efx->phy_mode = phy_mode;
644 int efx_reconfigure_port(struct efx_nic *efx)
648 EFX_ASSERT_RESET_SERIALISED(efx);
650 mutex_lock(&efx->mac_lock);
651 rc = __efx_reconfigure_port(efx);
652 mutex_unlock(&efx->mac_lock);
663 static void efx_wait_for_bist_end(struct efx_nic *efx)
668 if (efx_mcdi_poll_reboot(efx))
673 netif_err(efx, drv, efx->net_dev, "Warning: No MC reboot after BIST mode\n");
678 efx->mc_bist_for_other_fn = false;
686 int efx_try_recovery(struct efx_nic *efx)
694 struct eeh_dev *eehdev = pci_dev_to_eeh_dev(efx->pci_dev);
708 void efx_reset_down(struct efx_nic *efx, enum reset_type method)
710 EFX_ASSERT_RESET_SERIALISED(efx);
713 efx->type->prepare_flr(efx);
715 efx_stop_all(efx);
716 efx_disable_interrupts(efx);
718 mutex_lock(&efx->mac_lock);
719 down_write(&efx->filter_sem);
720 mutex_lock(&efx->rss_lock);
721 efx->type->fini(efx);
727 struct efx_nic *efx = netdev_priv(net_dev);
729 netif_err(efx, tx_err, efx->net_dev,
731 efx->port_enabled);
733 efx_schedule_reset(efx, RESET_TYPE_TX_WATCHDOG);
742 int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
746 EFX_ASSERT_RESET_SERIALISED(efx);
749 efx->type->finish_flr(efx);
752 rc = efx->type->init(efx);
754 netif_err(efx, drv, efx->net_dev, "failed to initialise NIC\n");
761 if (efx->port_initialized && method != RESET_TYPE_INVISIBLE &&
763 rc = efx_mcdi_port_reconfigure(efx);
765 netif_err(efx, drv, efx->net_dev,
769 rc = efx_enable_interrupts(efx);
774 rc = efx->type->vswitching_restore(efx);
776 netif_warn(efx, probe, efx->net_dev,
781 if (efx->type->rx_restore_rss_contexts)
782 efx->type->rx_restore_rss_contexts(efx);
783 mutex_unlock(&efx->rss_lock);
784 efx->type->filter_table_restore(efx);
785 up_write(&efx->filter_sem);
786 if (efx->type->sriov_reset)
787 efx->type->sriov_reset(efx);
789 mutex_unlock(&efx->mac_lock);
791 efx_start_all(efx);
793 if (efx->type->udp_tnl_push_ports)
794 efx->type->udp_tnl_push_ports(efx);
799 efx->port_initialized = false;
801 mutex_unlock(&efx->rss_lock);
802 up_write(&efx->filter_sem);
803 mutex_unlock(&efx->mac_lock);
813 int efx_reset(struct efx_nic *efx, enum reset_type method)
818 netif_info(efx, drv, efx->net_dev, "resetting (%s)\n",
821 efx_device_detach_sync(efx);
825 if (efx_nic_rev(efx) != EFX_REV_EF100)
826 efx_reset_down(efx, method);
828 rc = efx->type->reset(efx, method);
830 netif_err(efx, drv, efx->net_dev, "failed to reset hardware\n");
838 efx->reset_pending &= -(1 << (method + 1));
840 __clear_bit(method, &efx->reset_pending);
847 pci_set_master(efx->pci_dev);
854 if (efx_nic_rev(efx) != EFX_REV_EF100)
855 rc2 = efx_reset_up(efx, method, !disabled);
863 dev_close(efx->net_dev);
864 netif_err(efx, drv, efx->net_dev, "has been disabled\n");
865 efx->state = STATE_DISABLED;
867 netif_dbg(efx, drv, efx->net_dev, "reset complete\n");
868 efx_device_attach_if_not_resetting(efx);
878 struct efx_nic *efx = container_of(data, struct efx_nic, reset_work);
882 pending = READ_ONCE(efx->reset_pending);
886 efx_wait_for_bist_end(efx);
890 efx_try_recovery(efx))
902 if (efx_net_active(efx->state))
903 (void)efx_reset(efx, method);
908 void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
912 if (efx_recovering(efx->state)) {
913 netif_dbg(efx, drv, efx->net_dev,
930 netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",
934 method = efx->type->map_reset_reason(type);
935 netif_dbg(efx, drv, efx->net_dev,
941 set_bit(method, &efx->reset_pending);
947 if (!efx_net_active(READ_ONCE(efx->state)))
953 efx_mcdi_mode_poll(efx);
955 efx_queue_reset_work(efx);
967 int efx_port_dummy_op_int(struct efx_nic *efx)
971 void efx_port_dummy_op_void(struct efx_nic *efx) {}
982 int efx_init_struct(struct efx_nic *efx,
988 INIT_LIST_HEAD(&efx->node);
989 INIT_LIST_HEAD(&efx->secondary_list);
990 spin_lock_init(&efx->biu_lock);
992 INIT_LIST_HEAD(&efx->mtd_list);
994 INIT_WORK(&efx->reset_work, efx_reset_work);
995 INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);
996 efx_selftest_async_init(efx);
997 efx->pci_dev = pci_dev;
998 efx->msg_enable = debug;
999 efx->state = STATE_UNINIT;
1000 strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
1002 efx->net_dev = net_dev;
1003 efx->rx_prefix_size = efx->type->rx_prefix_size;
1004 efx->rx_ip_align =
1005 NET_IP_ALIGN ? (efx->rx_prefix_size + NET_IP_ALIGN) % 4 : 0;
1006 efx->rx_packet_hash_offset =
1007 efx->type->rx_hash_offset - efx->type->rx_prefix_size;
1008 efx->rx_packet_ts_offset =
1009 efx->type->rx_ts_offset - efx->type->rx_prefix_size;
1010 INIT_LIST_HEAD(&efx->rss_context.list);
1011 efx->rss_context.context_id = EFX_MCDI_RSS_CONTEXT_INVALID;
1012 mutex_init(&efx->rss_lock);
1013 efx->vport_id = EVB_PORT_ID_ASSIGNED;
1014 spin_lock_init(&efx->stats_lock);
1015 efx->vi_stride = EFX_DEFAULT_VI_STRIDE;
1016 efx->num_mac_stats = MC_CMD_MAC_NSTATS;
1018 mutex_init(&efx->mac_lock);
1019 init_rwsem(&efx->filter_sem);
1021 mutex_init(&efx->rps_mutex);
1022 spin_lock_init(&efx->rps_hash_lock);
1024 efx->rps_hash_table = kcalloc(EFX_ARFS_HASH_TABLE_SIZE,
1025 sizeof(*efx->rps_hash_table), GFP_KERNEL);
1027 efx->mdio.dev = net_dev;
1028 INIT_WORK(&efx->mac_work, efx_mac_work);
1029 init_waitqueue_head(&efx->flush_wq);
1031 efx->tx_queues_per_channel = 1;
1032 efx->rxq_entries = EFX_DEFAULT_DMAQ_SIZE;
1033 efx->txq_entries = EFX_DEFAULT_DMAQ_SIZE;
1035 efx->mem_bar = UINT_MAX;
1037 rc = efx_init_channels(efx);
1042 snprintf(efx->workqueue_name, sizeof(efx->workqueue_name), "sfc%s",
1044 efx->workqueue = create_singlethread_workqueue(efx->workqueue_name);
1045 if (!efx->workqueue) {
1053 efx_fini_struct(efx);
1057 void efx_fini_struct(struct efx_nic *efx)
1060 kfree(efx->rps_hash_table);
1063 efx_fini_channels(efx);
1065 kfree(efx->vpd_sn);
1067 if (efx->workqueue) {
1068 destroy_workqueue(efx->workqueue);
1069 efx->workqueue = NULL;
1074 int efx_init_io(struct efx_nic *efx, int bar, dma_addr_t dma_mask,
1077 struct pci_dev *pci_dev = efx->pci_dev;
1080 efx->mem_bar = UINT_MAX;
1082 netif_dbg(efx, probe, efx->net_dev, "initialising I/O bar=%d\n", bar);
1086 netif_err(efx, probe, efx->net_dev,
1095 netif_err(efx, probe, efx->net_dev,
1099 netif_dbg(efx, probe, efx->net_dev,
1102 efx->membase_phys = pci_resource_start(efx->pci_dev, bar);
1103 if (!efx->membase_phys) {
1104 netif_err(efx, probe, efx->net_dev,
1113 netif_err(efx, probe, efx->net_dev,
1118 efx->mem_bar = bar;
1119 efx->membase = ioremap(efx->membase_phys, mem_map_size);
1120 if (!efx->membase) {
1121 netif_err(efx, probe, efx->net_dev,
1123 (unsigned long long)efx->membase_phys, mem_map_size);
1127 netif_dbg(efx, probe, efx->net_dev,
1129 (unsigned long long)efx->membase_phys, mem_map_size,
1130 efx->membase);
1135 pci_release_region(efx->pci_dev, bar);
1137 efx->membase_phys = 0;
1139 pci_disable_device(efx->pci_dev);
1144 void efx_fini_io(struct efx_nic *efx)
1146 netif_dbg(efx, drv, efx->net_dev, "shutting down I/O\n");
1148 if (efx->membase) {
1149 iounmap(efx->membase);
1150 efx->membase = NULL;
1153 if (efx->membase_phys) {
1154 pci_release_region(efx->pci_dev, efx->mem_bar);
1155 efx->membase_phys = 0;
1156 efx->mem_bar = UINT_MAX;
1160 if (!pci_vfs_assigned(efx->pci_dev))
1161 pci_disable_device(efx->pci_dev);
1168 struct efx_nic *efx = dev_get_drvdata(dev);
1169 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1177 struct efx_nic *efx = dev_get_drvdata(dev);
1178 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1187 void efx_init_mcdi_logging(struct efx_nic *efx)
1189 int rc = device_create_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);
1192 netif_warn(efx, drv, efx->net_dev,
1197 void efx_fini_mcdi_logging(struct efx_nic *efx)
1199 device_remove_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);
1211 struct efx_nic *efx = pci_get_drvdata(pdev);
1218 if (efx->state != STATE_DISABLED) {
1219 efx->state = efx_recover(efx->state);
1220 efx->reset_pending = 0;
1222 efx_device_detach_sync(efx);
1224 efx_stop_all(efx);
1225 efx_disable_interrupts(efx);
1245 struct efx_nic *efx = pci_get_drvdata(pdev);
1249 netif_err(efx, hw, efx->net_dev,
1260 struct efx_nic *efx = pci_get_drvdata(pdev);
1265 if (efx->state == STATE_DISABLED)
1268 rc = efx_reset(efx, RESET_TYPE_ALL);
1270 netif_err(efx, hw, efx->net_dev,
1273 efx->state = efx_recovered(efx->state);
1274 netif_dbg(efx, hw, efx->net_dev,
1297 static bool efx_can_encap_offloads(struct efx_nic *efx, struct sk_buff *skb)
1307 if (WARN_ON_ONCE(!efx->type->udp_tnl_has_port))
1350 return efx->type->udp_tnl_has_port(efx, dst_port);
1359 struct efx_nic *efx = netdev_priv(dev);
1370 if (!efx_can_encap_offloads(efx, skb))
1380 struct efx_nic *efx = netdev_priv(net_dev);
1382 if (efx->type->get_phys_port_id)
1383 return efx->type->get_phys_port_id(efx, ppid);
1390 struct efx_nic *efx = netdev_priv(net_dev);
1392 if (snprintf(name, len, "p%u", efx->port_num) >= len)