Commit f1826756 authored by Alex Maftei (amaftei)'s avatar Alex Maftei (amaftei) Committed by David S. Miller
Browse files

sfc: move struct init and fini code 



The hardware monitor code and the reset work queue code were also
moved, with supporting macros and parameters, because they are assigned
to function pointers in the struct.
Small code styling fixes included.

Signed-off-by: default avatarAlexandru-Mihai Maftei <amaftei@solarflare.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 1eaf99fe

drivers/net/ethernet/sfc/efx.c

+4 −371
Original line number Diff line number Diff line
@@ -43,56 +43,6 @@ 
 **************************************************************************

 */



/* Loopback mode names (see LOOPBACK_MODE()) */

const unsigned int efx_loopback_mode_max = LOOPBACK_MAX;

const char *const efx_loopback_mode_names[] = {

	[LOOPBACK_NONE]		= "NONE",

	[LOOPBACK_DATA]		= "DATAPATH",

	[LOOPBACK_GMAC]		= "GMAC",

	[LOOPBACK_XGMII]	= "XGMII",

	[LOOPBACK_XGXS]		= "XGXS",

	[LOOPBACK_XAUI]		= "XAUI",

	[LOOPBACK_GMII]		= "GMII",

	[LOOPBACK_SGMII]	= "SGMII",

	[LOOPBACK_XGBR]		= "XGBR",

	[LOOPBACK_XFI]		= "XFI",

	[LOOPBACK_XAUI_FAR]	= "XAUI_FAR",

	[LOOPBACK_GMII_FAR]	= "GMII_FAR",

	[LOOPBACK_SGMII_FAR]	= "SGMII_FAR",

	[LOOPBACK_XFI_FAR]	= "XFI_FAR",

	[LOOPBACK_GPHY]		= "GPHY",

	[LOOPBACK_PHYXS]	= "PHYXS",

	[LOOPBACK_PCS]		= "PCS",

	[LOOPBACK_PMAPMD]	= "PMA/PMD",

	[LOOPBACK_XPORT]	= "XPORT",

	[LOOPBACK_XGMII_WS]	= "XGMII_WS",

	[LOOPBACK_XAUI_WS]	= "XAUI_WS",

	[LOOPBACK_XAUI_WS_FAR]  = "XAUI_WS_FAR",

	[LOOPBACK_XAUI_WS_NEAR] = "XAUI_WS_NEAR",

	[LOOPBACK_GMII_WS]	= "GMII_WS",

	[LOOPBACK_XFI_WS]	= "XFI_WS",

	[LOOPBACK_XFI_WS_FAR]	= "XFI_WS_FAR",

	[LOOPBACK_PHYXS_WS]	= "PHYXS_WS",

};



const unsigned int efx_reset_type_max = RESET_TYPE_MAX;

const char *const efx_reset_type_names[] = {

	[RESET_TYPE_INVISIBLE]          = "INVISIBLE",

	[RESET_TYPE_ALL]                = "ALL",

	[RESET_TYPE_RECOVER_OR_ALL]     = "RECOVER_OR_ALL",

	[RESET_TYPE_WORLD]              = "WORLD",

	[RESET_TYPE_RECOVER_OR_DISABLE] = "RECOVER_OR_DISABLE",

	[RESET_TYPE_DATAPATH]           = "DATAPATH",

	[RESET_TYPE_MC_BIST]		= "MC_BIST",

	[RESET_TYPE_DISABLE]            = "DISABLE",

	[RESET_TYPE_TX_WATCHDOG]        = "TX_WATCHDOG",

	[RESET_TYPE_INT_ERROR]          = "INT_ERROR",

	[RESET_TYPE_DMA_ERROR]          = "DMA_ERROR",

	[RESET_TYPE_TX_SKIP]            = "TX_SKIP",

	[RESET_TYPE_MC_FAILURE]         = "MC_FAILURE",

	[RESET_TYPE_MCDI_TIMEOUT]	= "MCDI_TIMEOUT (FLR)",

};



/* UDP tunnel type names */

static const char *const efx_udp_tunnel_type_names[] = {

	[TUNNEL_ENCAP_UDP_PORT_ENTRY_VXLAN] = "vxlan",
@@ -108,12 +58,6 @@ void efx_get_udp_tunnel_type_name(u16 type, char *buf, size_t buflen) 
		snprintf(buf, buflen, "type %d", type);

}



/* How often and how many times to poll for a reset while waiting for a

 * BIST that another function started to complete.

 */

#define BIST_WAIT_DELAY_MS	100

#define BIST_WAIT_DELAY_COUNT	100



/**************************************************************************

 *

 * Configurable values
@@ -138,16 +82,6 @@ MODULE_PARM_DESC(efx_separate_tx_channels, 
 */

static int napi_weight = 64;



/* This is the time (in jiffies) between invocations of the hardware

 * monitor.

 * On Falcon-based NICs, this will:

 * - Check the on-board hardware monitor;

 * - Poll the link state and reconfigure the hardware as necessary.

 * On Siena-based NICs for power systems with EEH support, this will give EEH a

 * chance to start.

 */

static unsigned int efx_monitor_interval = 1 * HZ;



/* Initial interrupt moderation settings.  They can be modified after

 * module load with ethtool.

 *
@@ -830,19 +764,6 @@ void efx_link_set_wanted_fc(struct efx_nic *efx, u8 wanted_fc) 


static void efx_fini_port(struct efx_nic *efx);



/* Asynchronous work item for changing MAC promiscuity and multicast

 * hash.  Avoid a drain/rx_ingress enable by reconfiguring the current

 * MAC directly. */

static void efx_mac_work(struct work_struct *data)

{

	struct efx_nic *efx = container_of(data, struct efx_nic, mac_work);



	mutex_lock(&efx->mac_lock);

	if (efx->port_enabled)

		efx_mac_reconfigure(efx);

	mutex_unlock(&efx->mac_lock);

}



static int efx_probe_port(struct efx_nic *efx)

{

	int rc;
@@ -994,94 +915,6 @@ static void efx_dissociate(struct efx_nic *efx) 
	}

}



/* This configures the PCI device to enable I/O and DMA. */

int efx_init_io(struct efx_nic *efx, int bar, dma_addr_t dma_mask,

		unsigned int mem_map_size)

{

	struct pci_dev *pci_dev = efx->pci_dev;

	int rc;



	netif_dbg(efx, probe, efx->net_dev, "initialising I/O\n");



	rc = pci_enable_device(pci_dev);

	if (rc) {

		netif_err(efx, probe, efx->net_dev,

			  "failed to enable PCI device\n");

		goto fail1;

	}



	pci_set_master(pci_dev);



	/* Set the PCI DMA mask.  Try all possibilities from our genuine mask

	 * down to 32 bits, because some architectures will allow 40 bit

	 * masks event though they reject 46 bit masks.

	 */

	while (dma_mask > 0x7fffffffUL) {

		rc = dma_set_mask_and_coherent(&pci_dev->dev, dma_mask);

		if (rc == 0)

			break;

		dma_mask >>= 1;

	}

	if (rc) {

		netif_err(efx, probe, efx->net_dev,

			  "could not find a suitable DMA mask\n");

		goto fail2;

	}

	netif_dbg(efx, probe, efx->net_dev,

		  "using DMA mask %llx\n", (unsigned long long) dma_mask);



	efx->membase_phys = pci_resource_start(efx->pci_dev, bar);

	rc = pci_request_region(pci_dev, bar, "sfc");

	if (rc) {

		netif_err(efx, probe, efx->net_dev,

			  "request for memory BAR failed\n");

		rc = -EIO;

		goto fail3;

	}

	efx->membase = ioremap_nocache(efx->membase_phys, mem_map_size);

	if (!efx->membase) {

		netif_err(efx, probe, efx->net_dev,

			  "could not map memory BAR at %llx+%x\n",

			  (unsigned long long)efx->membase_phys, mem_map_size);

		rc = -ENOMEM;

		goto fail4;

	}

	netif_dbg(efx, probe, efx->net_dev,

		  "memory BAR at %llx+%x (virtual %p)\n",

		  (unsigned long long)efx->membase_phys, mem_map_size,

		  efx->membase);



	return 0;



 fail4:

	pci_release_region(efx->pci_dev, bar);

 fail3:

	efx->membase_phys = 0;

 fail2:

	pci_disable_device(efx->pci_dev);

 fail1:

	return rc;

}



void efx_fini_io(struct efx_nic *efx, int bar)

{

	netif_dbg(efx, drv, efx->net_dev, "shutting down I/O\n");



	if (efx->membase) {

		iounmap(efx->membase);

		efx->membase = NULL;

	}



	if (efx->membase_phys) {

		pci_release_region(efx->pci_dev, bar);

		efx->membase_phys = 0;

	}



	/* Don't disable bus-mastering if VFs are assigned */

	if (!pci_vfs_assigned(efx->pci_dev))

		pci_disable_device(efx->pci_dev);

}



void efx_set_default_rx_indir_table(struct efx_nic *efx,

				    struct efx_rss_context *ctx)

{
@@ -1855,43 +1688,6 @@ void efx_get_irq_moderation(struct efx_nic *efx, unsigned int *tx_usecs, 
	}

}



/**************************************************************************

 *

 * Hardware monitor

 *

 **************************************************************************/



/* Run periodically off the general workqueue */

static void efx_monitor(struct work_struct *data)

{

	struct efx_nic *efx = container_of(data, struct efx_nic,

					   monitor_work.work);



	netif_vdbg(efx, timer, efx->net_dev,

		   "hardware monitor executing on CPU %d\n",

		   raw_smp_processor_id());

	BUG_ON(efx->type->monitor == NULL);



	/* If the mac_lock is already held then it is likely a port

	 * reconfiguration is already in place, which will likely do

	 * most of the work of monitor() anyway. */

	if (mutex_trylock(&efx->mac_lock)) {

		if (efx->port_enabled)

			efx->type->monitor(efx);

		mutex_unlock(&efx->mac_lock);

	}



	queue_delayed_work(efx->workqueue, &efx->monitor_work,

			   efx_monitor_interval);

}



void efx_start_monitor(struct efx_nic *efx)

{

	if (efx->type->monitor)

		queue_delayed_work(efx->workqueue, &efx->monitor_work,

				   efx_monitor_interval);

}



/**************************************************************************

 *

 * ioctls
@@ -2477,65 +2273,6 @@ static void efx_unregister_netdev(struct efx_nic *efx) 
	}

}



/**************************************************************************

 *

 * Device reset and suspend

 *

 **************************************************************************/



static void efx_wait_for_bist_end(struct efx_nic *efx)

{

	int i;



	for (i = 0; i < BIST_WAIT_DELAY_COUNT; ++i) {

		if (efx_mcdi_poll_reboot(efx))

			goto out;

		msleep(BIST_WAIT_DELAY_MS);

	}



	netif_err(efx, drv, efx->net_dev, "Warning: No MC reboot after BIST mode\n");

out:

	/* Either way unset the BIST flag. If we found no reboot we probably

	 * won't recover, but we should try.

	 */

	efx->mc_bist_for_other_fn = false;

}



/* The worker thread exists so that code that cannot sleep can

 * schedule a reset for later.

 */

static void efx_reset_work(struct work_struct *data)

{

	struct efx_nic *efx = container_of(data, struct efx_nic, reset_work);

	unsigned long pending;

	enum reset_type method;



	pending = READ_ONCE(efx->reset_pending);

	method = fls(pending) - 1;



	if (method == RESET_TYPE_MC_BIST)

		efx_wait_for_bist_end(efx);



	if ((method == RESET_TYPE_RECOVER_OR_DISABLE ||

	     method == RESET_TYPE_RECOVER_OR_ALL) &&

	    efx_try_recovery(efx))

		return;



	if (!pending)

		return;



	rtnl_lock();



	/* We checked the state in efx_schedule_reset() but it may

	 * have changed by now.  Now that we have the RTNL lock,

	 * it cannot change again.

	 */

	if (efx->state == STATE_READY)

		(void)efx_reset(efx, method);



	rtnl_unlock();

}



/**************************************************************************

 *

 * List of NICs we support
@@ -2567,93 +2304,20 @@ static const struct pci_device_id efx_pci_table[] = { 
	{0}			/* end of list */

};



/**************************************************************************

 *

 * Dummy PHY/MAC operations

 *

 * Can be used for some unimplemented operations

 * Needed so all function pointers are valid and do not have to be tested

 * before use

 *

 **************************************************************************/

int efx_port_dummy_op_int(struct efx_nic *efx)

{

	return 0;

}

void efx_port_dummy_op_void(struct efx_nic *efx) {}



static bool efx_port_dummy_op_poll(struct efx_nic *efx)

{

	return false;

}



static const struct efx_phy_operations efx_dummy_phy_operations = {

	.init		 = efx_port_dummy_op_int,

	.reconfigure	 = efx_port_dummy_op_int,

	.poll		 = efx_port_dummy_op_poll,

	.fini		 = efx_port_dummy_op_void,

};



/**************************************************************************

 *

 * Data housekeeping

 *

 **************************************************************************/



/* This zeroes out and then fills in the invariants in a struct

 * efx_nic (including all sub-structures).

 */

int efx_init_struct(struct efx_nic *efx, struct pci_dev *pci_dev,

		    struct net_device *net_dev)

int efx_init_channels(struct efx_nic *efx)

{

	int rc = -ENOMEM, i;



	/* Initialise common structures */

	INIT_LIST_HEAD(&efx->node);

	INIT_LIST_HEAD(&efx->secondary_list);

	spin_lock_init(&efx->biu_lock);

#ifdef CONFIG_SFC_MTD

	INIT_LIST_HEAD(&efx->mtd_list);

#endif

	INIT_WORK(&efx->reset_work, efx_reset_work);

	INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);

	INIT_DELAYED_WORK(&efx->selftest_work, efx_selftest_async_work);

	efx->pci_dev = pci_dev;

	efx->msg_enable = debug;

	efx->state = STATE_UNINIT;

	strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));



	efx->net_dev = net_dev;

	efx->rx_prefix_size = efx->type->rx_prefix_size;

	efx->rx_ip_align =

		NET_IP_ALIGN ? (efx->rx_prefix_size + NET_IP_ALIGN) % 4 : 0;

	efx->rx_packet_hash_offset =

		efx->type->rx_hash_offset - efx->type->rx_prefix_size;

	efx->rx_packet_ts_offset =

		efx->type->rx_ts_offset - efx->type->rx_prefix_size;

	INIT_LIST_HEAD(&efx->rss_context.list);

	mutex_init(&efx->rss_lock);

	spin_lock_init(&efx->stats_lock);

	efx->vi_stride = EFX_DEFAULT_VI_STRIDE;

	efx->num_mac_stats = MC_CMD_MAC_NSTATS;

	BUILD_BUG_ON(MC_CMD_MAC_NSTATS - 1 != MC_CMD_MAC_GENERATION_END);

	mutex_init(&efx->mac_lock);

#ifdef CONFIG_RFS_ACCEL

	mutex_init(&efx->rps_mutex);

	spin_lock_init(&efx->rps_hash_lock);

	/* Failure to allocate is not fatal, but may degrade ARFS performance */

	efx->rps_hash_table = kcalloc(EFX_ARFS_HASH_TABLE_SIZE,

				      sizeof(*efx->rps_hash_table), GFP_KERNEL);

#endif

	efx->phy_op = &efx_dummy_phy_operations;

	efx->mdio.dev = net_dev;

	INIT_WORK(&efx->mac_work, efx_mac_work);

	init_waitqueue_head(&efx->flush_wq);

	unsigned int i;



	for (i = 0; i < EFX_MAX_CHANNELS; i++) {

		efx->channel[i] = efx_alloc_channel(efx, i, NULL);

		if (!efx->channel[i])

			goto fail;

			return -ENOMEM;

		efx->msi_context[i].efx = efx;

		efx->msi_context[i].index = i;

	}
@@ -2661,45 +2325,14 @@ int efx_init_struct(struct efx_nic *efx, struct pci_dev *pci_dev, 
	/* Higher numbered interrupt modes are less capable! */

	if (WARN_ON_ONCE(efx->type->max_interrupt_mode >

			 efx->type->min_interrupt_mode)) {

		rc = -EIO;

		goto fail;

		return -EIO;

	}

	efx->interrupt_mode = max(efx->type->max_interrupt_mode,

				  interrupt_mode);

	efx->interrupt_mode = min(efx->type->min_interrupt_mode,

				  interrupt_mode);



	/* Would be good to use the net_dev name, but we're too early */

	snprintf(efx->workqueue_name, sizeof(efx->workqueue_name), "sfc%s",

		 pci_name(pci_dev));

	efx->workqueue = create_singlethread_workqueue(efx->workqueue_name);

	if (!efx->workqueue)

		goto fail;



	return 0;



fail:

	efx_fini_struct(efx);

	return rc;

}



void efx_fini_struct(struct efx_nic *efx)

{

	int i;



#ifdef CONFIG_RFS_ACCEL

	kfree(efx->rps_hash_table);

#endif



	for (i = 0; i < EFX_MAX_CHANNELS; i++)

		kfree(efx->channel[i]);



	kfree(efx->vpd_sn);



	if (efx->workqueue) {

		destroy_workqueue(efx->workqueue);

		efx->workqueue = NULL;

	}

}



void efx_update_sw_stats(struct efx_nic *efx, u64 *stats)

drivers/net/ethernet/sfc/efx_common.c

+411 −0

File changed.

Preview size limit exceeded, changes collapsed.