Lines Matching refs:efx
18 #include "efx.h"
120 void efx_queue_reset_work(struct efx_nic *efx)
122 queue_work(reset_workqueue, &efx->reset_work);
125 void efx_flush_reset_workqueue(struct efx_nic *efx)
127 cancel_work_sync(&efx->reset_work);
138 /* We assume that efx->type->reconfigure_mac will always try to sync RX
141 void efx_mac_reconfigure(struct efx_nic *efx, bool mtu_only)
143 if (efx->type->reconfigure_mac) {
144 down_read(&efx->filter_sem);
145 efx->type->reconfigure_mac(efx, mtu_only);
146 up_read(&efx->filter_sem);
156 struct efx_nic *efx = container_of(data, struct efx_nic, mac_work);
158 mutex_lock(&efx->mac_lock);
159 if (efx->port_enabled)
160 efx_mac_reconfigure(efx, false);
161 mutex_unlock(&efx->mac_lock);
166 struct efx_nic *efx = efx_netdev_priv(net_dev);
173 netif_err(efx, drv, efx->net_dev,
182 if (efx->type->set_mac_address) {
183 rc = efx->type->set_mac_address(efx);
191 mutex_lock(&efx->mac_lock);
192 efx_mac_reconfigure(efx, false);
193 mutex_unlock(&efx->mac_lock);
201 struct efx_nic *efx = efx_netdev_priv(net_dev);
203 if (efx->port_enabled)
204 queue_work(efx->workqueue, &efx->mac_work);
210 struct efx_nic *efx = efx_netdev_priv(net_dev);
215 rc = efx->type->filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);
238 void efx_link_status_changed(struct efx_nic *efx)
240 struct efx_link_state *link_state = &efx->link_state;
247 if (!netif_running(efx->net_dev))
250 if (link_state->up != netif_carrier_ok(efx->net_dev)) {
251 efx->n_link_state_changes++;
254 netif_carrier_on(efx->net_dev);
256 netif_carrier_off(efx->net_dev);
261 netif_info(efx, link, efx->net_dev,
264 efx->net_dev->mtu);
266 netif_info(efx, link, efx->net_dev, "link down\n");
269 unsigned int efx_xdp_max_mtu(struct efx_nic *efx)
275 efx->rx_prefix_size + efx->type->rx_buffer_padding +
276 efx->rx_ip_align + EFX_XDP_HEADROOM + EFX_XDP_TAILROOM;
284 struct efx_nic *efx = efx_netdev_priv(net_dev);
287 rc = efx_check_disabled(efx);
291 if (rtnl_dereference(efx->xdp_prog) &&
292 new_mtu > efx_xdp_max_mtu(efx)) {
293 netif_err(efx, drv, efx->net_dev,
295 new_mtu, efx_xdp_max_mtu(efx));
299 netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);
301 efx_device_detach_sync(efx);
302 efx_stop_all(efx);
304 mutex_lock(&efx->mac_lock);
306 efx_mac_reconfigure(efx, true);
307 mutex_unlock(&efx->mac_lock);
309 efx_start_all(efx);
310 efx_device_attach_if_not_resetting(efx);
323 struct efx_nic *efx = container_of(data, struct efx_nic,
326 netif_vdbg(efx, timer, efx->net_dev,
329 BUG_ON(efx->type->monitor == NULL);
335 if (mutex_trylock(&efx->mac_lock)) {
336 if (efx->port_enabled && efx->type->monitor)
337 efx->type->monitor(efx);
338 mutex_unlock(&efx->mac_lock);
341 efx_start_monitor(efx);
344 void efx_start_monitor(struct efx_nic *efx)
346 if (efx->type->monitor)
347 queue_delayed_work(efx->workqueue, &efx->monitor_work,
361 static void efx_start_datapath(struct efx_nic *efx)
363 netdev_features_t old_features = efx->net_dev->features;
364 bool old_rx_scatter = efx->rx_scatter;
371 efx->rx_dma_len = (efx->rx_prefix_size +
372 EFX_MAX_FRAME_LEN(efx->net_dev->mtu) +
373 efx->type->rx_buffer_padding);
375 efx->rx_ip_align + efx->rx_dma_len + EFX_XDP_TAILROOM);
378 efx->rx_scatter = efx->type->always_rx_scatter;
379 efx->rx_buffer_order = 0;
380 } else if (efx->type->can_rx_scatter) {
386 efx->rx_scatter = true;
387 efx->rx_dma_len = EFX_RX_USR_BUF_SIZE;
388 efx->rx_buffer_order = 0;
390 efx->rx_scatter = false;
391 efx->rx_buffer_order = get_order(rx_buf_len);
394 efx_rx_config_page_split(efx);
395 if (efx->rx_buffer_order)
396 netif_dbg(efx, drv, efx->net_dev,
398 efx->rx_dma_len, efx->rx_buffer_order,
399 efx->rx_pages_per_batch);
401 netif_dbg(efx, drv, efx->net_dev,
403 efx->rx_dma_len, efx->rx_page_buf_step,
404 efx->rx_bufs_per_page, efx->rx_pages_per_batch);
409 efx->net_dev->hw_features |= efx->net_dev->features;
410 efx->net_dev->hw_features &= ~efx->fixed_features;
411 efx->net_dev->features |= efx->fixed_features;
412 if (efx->net_dev->features != old_features)
413 netdev_features_change(efx->net_dev);
416 if ((efx->rx_scatter != old_rx_scatter) &&
417 efx->type->filter_update_rx_scatter)
418 efx->type->filter_update_rx_scatter(efx);
427 efx->txq_stop_thresh = efx->txq_entries - efx_tx_max_skb_descs(efx);
428 efx->txq_wake_thresh = efx->txq_stop_thresh / 2;
431 efx_start_channels(efx);
433 efx_ptp_start_datapath(efx);
435 if (netif_device_present(efx->net_dev))
436 netif_tx_wake_all_queues(efx->net_dev);
439 static void efx_stop_datapath(struct efx_nic *efx)
441 EFX_ASSERT_RESET_SERIALISED(efx);
442 BUG_ON(efx->port_enabled);
444 efx_ptp_stop_datapath(efx);
446 efx_stop_channels(efx);
458 void efx_link_clear_advertising(struct efx_nic *efx)
460 bitmap_zero(efx->link_advertising, __ETHTOOL_LINK_MODE_MASK_NBITS);
461 efx->wanted_fc &= ~(EFX_FC_TX | EFX_FC_RX);
464 void efx_link_set_wanted_fc(struct efx_nic *efx, u8 wanted_fc)
466 efx->wanted_fc = wanted_fc;
467 if (efx->link_advertising[0]) {
469 efx->link_advertising[0] |= (ADVERTISED_Pause |
472 efx->link_advertising[0] &= ~(ADVERTISED_Pause |
475 efx->link_advertising[0] ^= ADVERTISED_Asym_Pause;
479 static void efx_start_port(struct efx_nic *efx)
481 netif_dbg(efx, ifup, efx->net_dev, "start port\n");
482 BUG_ON(efx->port_enabled);
484 mutex_lock(&efx->mac_lock);
485 efx->port_enabled = true;
488 efx_mac_reconfigure(efx, false);
490 mutex_unlock(&efx->mac_lock);
498 static void efx_stop_port(struct efx_nic *efx)
500 netif_dbg(efx, ifdown, efx->net_dev, "stop port\n");
502 EFX_ASSERT_RESET_SERIALISED(efx);
504 mutex_lock(&efx->mac_lock);
505 efx->port_enabled = false;
506 mutex_unlock(&efx->mac_lock);
509 netif_addr_lock_bh(efx->net_dev);
510 netif_addr_unlock_bh(efx->net_dev);
512 cancel_delayed_work_sync(&efx->monitor_work);
513 efx_selftest_async_cancel(efx);
514 cancel_work_sync(&efx->mac_work);
524 void efx_start_all(struct efx_nic *efx)
526 EFX_ASSERT_RESET_SERIALISED(efx);
527 BUG_ON(efx->state == STATE_DISABLED);
532 if (efx->port_enabled || !netif_running(efx->net_dev) ||
533 efx->reset_pending)
536 efx_start_port(efx);
537 efx_start_datapath(efx);
540 efx_start_monitor(efx);
542 efx_selftest_async_start(efx);
547 mutex_lock(&efx->mac_lock);
548 if (efx_mcdi_phy_poll(efx))
549 efx_link_status_changed(efx);
550 mutex_unlock(&efx->mac_lock);
552 if (efx->type->start_stats) {
553 efx->type->start_stats(efx);
554 efx->type->pull_stats(efx);
555 spin_lock_bh(&efx->stats_lock);
556 efx->type->update_stats(efx, NULL, NULL);
557 spin_unlock_bh(&efx->stats_lock);
566 void efx_stop_all(struct efx_nic *efx)
568 EFX_ASSERT_RESET_SERIALISED(efx);
571 if (!efx->port_enabled)
574 if (efx->type->update_stats) {
578 efx->type->pull_stats(efx);
579 spin_lock_bh(&efx->stats_lock);
580 efx->type->update_stats(efx, NULL, NULL);
581 spin_unlock_bh(&efx->stats_lock);
582 efx->type->stop_stats(efx);
585 efx_stop_port(efx);
591 WARN_ON(netif_running(efx->net_dev) &&
592 netif_device_present(efx->net_dev));
593 netif_tx_disable(efx->net_dev);
595 efx_stop_datapath(efx);
601 struct efx_nic *efx = efx_netdev_priv(net_dev);
603 spin_lock_bh(&efx->stats_lock);
604 efx_nic_update_stats_atomic(efx, NULL, stats);
605 spin_unlock_bh(&efx->stats_lock);
615 int __efx_reconfigure_port(struct efx_nic *efx)
620 WARN_ON(!mutex_is_locked(&efx->mac_lock));
623 phy_mode = efx->phy_mode;
624 if (LOOPBACK_INTERNAL(efx))
625 efx->phy_mode |= PHY_MODE_TX_DISABLED;
627 efx->phy_mode &= ~PHY_MODE_TX_DISABLED;
629 if (efx->type->reconfigure_port)
630 rc = efx->type->reconfigure_port(efx);
633 efx->phy_mode = phy_mode;
641 int efx_reconfigure_port(struct efx_nic *efx)
645 EFX_ASSERT_RESET_SERIALISED(efx);
647 mutex_lock(&efx->mac_lock);
648 rc = __efx_reconfigure_port(efx);
649 mutex_unlock(&efx->mac_lock);
660 static void efx_wait_for_bist_end(struct efx_nic *efx)
665 if (efx_mcdi_poll_reboot(efx))
670 netif_err(efx, drv, efx->net_dev, "Warning: No MC reboot after BIST mode\n");
675 efx->mc_bist_for_other_fn = false;
683 int efx_try_recovery(struct efx_nic *efx)
691 struct eeh_dev *eehdev = pci_dev_to_eeh_dev(efx->pci_dev);
705 void efx_reset_down(struct efx_nic *efx, enum reset_type method)
707 EFX_ASSERT_RESET_SERIALISED(efx);
710 efx->type->prepare_flr(efx);
712 efx_stop_all(efx);
713 efx_disable_interrupts(efx);
715 mutex_lock(&efx->mac_lock);
716 down_write(&efx->filter_sem);
717 mutex_lock(&efx->rss_lock);
718 efx->type->fini(efx);
724 struct efx_nic *efx = efx_netdev_priv(net_dev);
726 netif_err(efx, tx_err, efx->net_dev,
728 efx->port_enabled);
730 efx_schedule_reset(efx, RESET_TYPE_TX_WATCHDOG);
739 int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok)
743 EFX_ASSERT_RESET_SERIALISED(efx);
746 efx->type->finish_flr(efx);
749 rc = efx->type->init(efx);
751 netif_err(efx, drv, efx->net_dev, "failed to initialise NIC\n");
758 if (efx->port_initialized && method != RESET_TYPE_INVISIBLE &&
760 rc = efx_mcdi_port_reconfigure(efx);
762 netif_err(efx, drv, efx->net_dev,
766 rc = efx_enable_interrupts(efx);
771 rc = efx->type->vswitching_restore(efx);
773 netif_warn(efx, probe, efx->net_dev,
778 if (efx->type->rx_restore_rss_contexts)
779 efx->type->rx_restore_rss_contexts(efx);
780 mutex_unlock(&efx->rss_lock);
781 efx->type->filter_table_restore(efx);
782 up_write(&efx->filter_sem);
784 mutex_unlock(&efx->mac_lock);
786 efx_start_all(efx);
788 if (efx->type->udp_tnl_push_ports)
789 efx->type->udp_tnl_push_ports(efx);
794 efx->port_initialized = false;
796 mutex_unlock(&efx->rss_lock);
797 up_write(&efx->filter_sem);
798 mutex_unlock(&efx->mac_lock);
808 int efx_reset(struct efx_nic *efx, enum reset_type method)
813 netif_info(efx, drv, efx->net_dev, "resetting (%s)\n",
816 efx_device_detach_sync(efx);
820 if (efx_nic_rev(efx) != EFX_REV_EF100)
821 efx_reset_down(efx, method);
823 rc = efx->type->reset(efx, method);
825 netif_err(efx, drv, efx->net_dev, "failed to reset hardware\n");
833 efx->reset_pending &= -(1 << (method + 1));
835 __clear_bit(method, &efx->reset_pending);
842 pci_set_master(efx->pci_dev);
849 if (efx_nic_rev(efx) != EFX_REV_EF100)
850 rc2 = efx_reset_up(efx, method, !disabled);
858 dev_close(efx->net_dev);
859 netif_err(efx, drv, efx->net_dev, "has been disabled\n");
860 efx->state = STATE_DISABLED;
862 netif_dbg(efx, drv, efx->net_dev, "reset complete\n");
863 efx_device_attach_if_not_resetting(efx);
873 struct efx_nic *efx = container_of(data, struct efx_nic, reset_work);
877 pending = READ_ONCE(efx->reset_pending);
881 efx_wait_for_bist_end(efx);
885 efx_try_recovery(efx))
897 if (efx_net_active(efx->state))
898 (void)efx_reset(efx, method);
903 void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
907 if (efx_recovering(efx->state)) {
908 netif_dbg(efx, drv, efx->net_dev,
925 netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",
929 method = efx->type->map_reset_reason(type);
930 netif_dbg(efx, drv, efx->net_dev,
936 set_bit(method, &efx->reset_pending);
942 if (!efx_net_active(READ_ONCE(efx->state)))
948 efx_mcdi_mode_poll(efx);
950 efx_queue_reset_work(efx);
962 int efx_port_dummy_op_int(struct efx_nic *efx)
966 void efx_port_dummy_op_void(struct efx_nic *efx) {}
977 int efx_init_struct(struct efx_nic *efx, struct pci_dev *pci_dev)
982 INIT_LIST_HEAD(&efx->node);
983 INIT_LIST_HEAD(&efx->secondary_list);
984 spin_lock_init(&efx->biu_lock);
986 INIT_LIST_HEAD(&efx->mtd_list);
988 INIT_WORK(&efx->reset_work, efx_reset_work);
989 INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);
990 efx_selftest_async_init(efx);
991 efx->pci_dev = pci_dev;
992 efx->msg_enable = debug;
993 efx->state = STATE_UNINIT;
994 strscpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
996 efx->rx_prefix_size = efx->type->rx_prefix_size;
997 efx->rx_ip_align =
998 NET_IP_ALIGN ? (efx->rx_prefix_size + NET_IP_ALIGN) % 4 : 0;
999 efx->rx_packet_hash_offset =
1000 efx->type->rx_hash_offset - efx->type->rx_prefix_size;
1001 efx->rx_packet_ts_offset =
1002 efx->type->rx_ts_offset - efx->type->rx_prefix_size;
1003 INIT_LIST_HEAD(&efx->rss_context.list);
1004 efx->rss_context.context_id = EFX_MCDI_RSS_CONTEXT_INVALID;
1005 mutex_init(&efx->rss_lock);
1006 efx->vport_id = EVB_PORT_ID_ASSIGNED;
1007 spin_lock_init(&efx->stats_lock);
1008 efx->vi_stride = EFX_DEFAULT_VI_STRIDE;
1009 efx->num_mac_stats = MC_CMD_MAC_NSTATS;
1011 mutex_init(&efx->mac_lock);
1012 init_rwsem(&efx->filter_sem);
1014 mutex_init(&efx->rps_mutex);
1015 spin_lock_init(&efx->rps_hash_lock);
1017 efx->rps_hash_table = kcalloc(EFX_ARFS_HASH_TABLE_SIZE,
1018 sizeof(*efx->rps_hash_table), GFP_KERNEL);
1020 spin_lock_init(&efx->vf_reps_lock);
1021 INIT_LIST_HEAD(&efx->vf_reps);
1022 INIT_WORK(&efx->mac_work, efx_mac_work);
1023 init_waitqueue_head(&efx->flush_wq);
1025 efx->tx_queues_per_channel = 1;
1026 efx->rxq_entries = EFX_DEFAULT_DMAQ_SIZE;
1027 efx->txq_entries = EFX_DEFAULT_DMAQ_SIZE;
1029 efx->mem_bar = UINT_MAX;
1031 rc = efx_init_channels(efx);
1036 snprintf(efx->workqueue_name, sizeof(efx->workqueue_name), "sfc%s",
1038 efx->workqueue = create_singlethread_workqueue(efx->workqueue_name);
1039 if (!efx->workqueue) {
1047 efx_fini_struct(efx);
1051 void efx_fini_struct(struct efx_nic *efx)
1054 kfree(efx->rps_hash_table);
1057 efx_fini_channels(efx);
1059 kfree(efx->vpd_sn);
1061 if (efx->workqueue) {
1062 destroy_workqueue(efx->workqueue);
1063 efx->workqueue = NULL;
1068 int efx_init_io(struct efx_nic *efx, int bar, dma_addr_t dma_mask,
1071 struct pci_dev *pci_dev = efx->pci_dev;
1074 efx->mem_bar = UINT_MAX;
1087 pci_err(efx->pci_dev, "could not find a suitable DMA mask\n");
1090 pci_dbg(efx->pci_dev, "using DMA mask %llx\n", (unsigned long long)dma_mask);
1092 efx->membase_phys = pci_resource_start(efx->pci_dev, bar);
1093 if (!efx->membase_phys) {
1094 pci_err(efx->pci_dev,
1103 pci_err(efx->pci_dev,
1108 efx->mem_bar = bar;
1109 efx->membase = ioremap(efx->membase_phys, mem_map_size);
1110 if (!efx->membase) {
1111 pci_err(efx->pci_dev,
1113 (unsigned long long)efx->membase_phys, mem_map_size);
1117 pci_dbg(efx->pci_dev,
1119 (unsigned long long)efx->membase_phys, mem_map_size,
1120 efx->membase);
1125 pci_release_region(efx->pci_dev, bar);
1127 efx->membase_phys = 0;
1129 pci_disable_device(efx->pci_dev);
1134 void efx_fini_io(struct efx_nic *efx)
1136 pci_dbg(efx->pci_dev, "shutting down I/O\n");
1138 if (efx->membase) {
1139 iounmap(efx->membase);
1140 efx->membase = NULL;
1143 if (efx->membase_phys) {
1144 pci_release_region(efx->pci_dev, efx->mem_bar);
1145 efx->membase_phys = 0;
1146 efx->mem_bar = UINT_MAX;
1150 if (!pci_vfs_assigned(efx->pci_dev))
1151 pci_disable_device(efx->pci_dev);
1159 struct efx_nic *efx = dev_get_drvdata(dev);
1160 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1169 struct efx_nic *efx = dev_get_drvdata(dev);
1170 struct efx_mcdi_iface *mcdi = efx_mcdi(efx);
1179 void efx_init_mcdi_logging(struct efx_nic *efx)
1181 int rc = device_create_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);
1184 netif_warn(efx, drv, efx->net_dev,
1189 void efx_fini_mcdi_logging(struct efx_nic *efx)
1191 device_remove_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);
1203 struct efx_nic *efx = pci_get_drvdata(pdev);
1210 if (efx->state != STATE_DISABLED) {
1211 efx->state = efx_recover(efx->state);
1212 efx->reset_pending = 0;
1214 efx_device_detach_sync(efx);
1216 if (efx_net_active(efx->state)) {
1217 efx_stop_all(efx);
1218 efx_disable_interrupts(efx);
1239 struct efx_nic *efx = pci_get_drvdata(pdev);
1243 netif_err(efx, hw, efx->net_dev,
1254 struct efx_nic *efx = pci_get_drvdata(pdev);
1259 if (efx->state == STATE_DISABLED)
1262 rc = efx_reset(efx, RESET_TYPE_ALL);
1264 netif_err(efx, hw, efx->net_dev,
1267 efx->state = efx_recovered(efx->state);
1268 netif_dbg(efx, hw, efx->net_dev,
1291 static bool efx_can_encap_offloads(struct efx_nic *efx, struct sk_buff *skb)
1301 if (WARN_ON_ONCE(!efx->type->udp_tnl_has_port))
1344 return efx->type->udp_tnl_has_port(efx, dst_port);
1353 struct efx_nic *efx = efx_netdev_priv(dev);
1364 if (!efx_can_encap_offloads(efx, skb))
1374 struct efx_nic *efx = efx_netdev_priv(net_dev);
1376 if (efx->type->get_phys_port_id)
1377 return efx->type->get_phys_port_id(efx, ppid);
1384 struct efx_nic *efx = efx_netdev_priv(net_dev);
1386 if (snprintf(name, len, "p%u", efx->port_num) >= len)
1391 void efx_detach_reps(struct efx_nic *efx)
1397 netif_dbg(efx, drv, efx->net_dev, "Detaching VF representors\n");
1398 list_for_each_entry(efv, &efx->vf_reps, list) {
1410 void efx_attach_reps(struct efx_nic *efx)
1416 netif_dbg(efx, drv, efx->net_dev, "Attaching VF representors\n");
1417 list_for_each_entry(efv, &efx->vf_reps, list) {