Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 62776d03 authored by Ben Hutchings's avatar Ben Hutchings Committed by David S. Miller
Browse files

sfc: Implement message level control 



Replace EFX_ERR() with netif_err(), EFX_INFO() with netif_info(),
EFX_LOG() with netif_dbg() and EFX_TRACE() and EFX_REGDUMP() with
netif_vdbg().

Replace EFX_ERR_RL(), EFX_INFO_RL() and EFX_LOG_RL() using explicit
calls to net_ratelimit().

Implement the ethtool operations to get and set message level flags,
and add a 'debug' module parameter for the initial value.

Signed-off-by: default avatarBen Hutchings <bhutchings@solarflare.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 0c605a20

drivers/net/sfc/efx.c

+135 −88
Original line number Diff line number Diff line
@@ -189,6 +189,13 @@ module_param(irq_adapt_high_thresh, uint, 0644); 
MODULE_PARM_DESC(irq_adapt_high_thresh,

		 "Threshold score for increasing IRQ moderation");



static unsigned debug = (NETIF_MSG_DRV | NETIF_MSG_PROBE |

			 NETIF_MSG_LINK | NETIF_MSG_IFDOWN |

			 NETIF_MSG_IFUP | NETIF_MSG_RX_ERR |

			 NETIF_MSG_TX_ERR | NETIF_MSG_HW);

module_param(debug, uint, 0);

MODULE_PARM_DESC(debug, "Bitmapped debugging message enable value");



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

 *

 * Utility functions and prototypes
@@ -272,16 +279,16 @@ static int efx_poll(struct napi_struct *napi, int budget) 
{

	struct efx_channel *channel =

		container_of(napi, struct efx_channel, napi_str);

	struct efx_nic *efx = channel->efx;

	int spent;



	EFX_TRACE(channel->efx, "channel %d NAPI poll executing on CPU %d\n",

	netif_vdbg(efx, intr, efx->net_dev,

		   "channel %d NAPI poll executing on CPU %d\n",

		   channel->channel, raw_smp_processor_id());



	spent = efx_process_channel(channel, budget);



	if (spent < budget) {

		struct efx_nic *efx = channel->efx;



		if (channel->channel < efx->n_rx_channels &&

		    efx->irq_rx_adaptive &&

		    unlikely(++channel->irq_count == 1000)) {
@@ -357,7 +364,8 @@ void efx_process_channel_now(struct efx_channel *channel) 
 */

static int efx_probe_eventq(struct efx_channel *channel)

{

	EFX_LOG(channel->efx, "chan %d create event queue\n", channel->channel);

	netif_dbg(channel->efx, probe, channel->efx->net_dev,

		  "chan %d create event queue\n", channel->channel);



	return efx_nic_probe_eventq(channel);

}
@@ -365,7 +373,8 @@ static int efx_probe_eventq(struct efx_channel *channel) 
/* Prepare channel's event queue */

static void efx_init_eventq(struct efx_channel *channel)

{

	EFX_LOG(channel->efx, "chan %d init event queue\n", channel->channel);

	netif_dbg(channel->efx, drv, channel->efx->net_dev,

		  "chan %d init event queue\n", channel->channel);



	channel->eventq_read_ptr = 0;
@@ -374,14 +383,16 @@ static void efx_init_eventq(struct efx_channel *channel) 


static void efx_fini_eventq(struct efx_channel *channel)

{

	EFX_LOG(channel->efx, "chan %d fini event queue\n", channel->channel);

	netif_dbg(channel->efx, drv, channel->efx->net_dev,

		  "chan %d fini event queue\n", channel->channel);



	efx_nic_fini_eventq(channel);

}



static void efx_remove_eventq(struct efx_channel *channel)

{

	EFX_LOG(channel->efx, "chan %d remove event queue\n", channel->channel);

	netif_dbg(channel->efx, drv, channel->efx->net_dev,

		  "chan %d remove event queue\n", channel->channel);



	efx_nic_remove_eventq(channel);

}
@@ -398,7 +409,8 @@ static int efx_probe_channel(struct efx_channel *channel) 
	struct efx_rx_queue *rx_queue;

	int rc;



	EFX_LOG(channel->efx, "creating channel %d\n", channel->channel);

	netif_dbg(channel->efx, probe, channel->efx->net_dev,

		  "creating channel %d\n", channel->channel);



	rc = efx_probe_eventq(channel);

	if (rc)
@@ -474,7 +486,8 @@ static void efx_init_channels(struct efx_nic *efx) 


	/* Initialise the channels */

	efx_for_each_channel(channel, efx) {

		EFX_LOG(channel->efx, "init chan %d\n", channel->channel);

		netif_dbg(channel->efx, drv, channel->efx->net_dev,

			  "init chan %d\n", channel->channel);



		efx_init_eventq(channel);
@@ -501,7 +514,8 @@ static void efx_start_channel(struct efx_channel *channel) 
{

	struct efx_rx_queue *rx_queue;



	EFX_LOG(channel->efx, "starting chan %d\n", channel->channel);

	netif_dbg(channel->efx, ifup, channel->efx->net_dev,

		  "starting chan %d\n", channel->channel);



	/* The interrupt handler for this channel may set work_pending

	 * as soon as we enable it.  Make sure it's cleared before
@@ -526,7 +540,8 @@ static void efx_stop_channel(struct efx_channel *channel) 
	if (!channel->enabled)

		return;



	EFX_LOG(channel->efx, "stop chan %d\n", channel->channel);

	netif_dbg(channel->efx, ifdown, channel->efx->net_dev,

		  "stop chan %d\n", channel->channel);



	channel->enabled = false;

	napi_disable(&channel->napi_str);
@@ -548,16 +563,19 @@ static void efx_fini_channels(struct efx_nic *efx) 
		 * descriptor caches reference memory we're about to free,

		 * but falcon_reconfigure_mac_wrapper() won't reconnect

		 * the MACs because of the pending reset. */

		EFX_ERR(efx, "Resetting to recover from flush failure\n");

		netif_err(efx, drv, efx->net_dev,

			  "Resetting to recover from flush failure\n");

		efx_schedule_reset(efx, RESET_TYPE_ALL);

	} else if (rc) {

		EFX_ERR(efx, "failed to flush queues\n");

		netif_err(efx, drv, efx->net_dev, "failed to flush queues\n");

	} else {

		EFX_LOG(efx, "successfully flushed all queues\n");

		netif_dbg(efx, drv, efx->net_dev,

			  "successfully flushed all queues\n");

	}



	efx_for_each_channel(channel, efx) {

		EFX_LOG(channel->efx, "shut down chan %d\n", channel->channel);

		netif_dbg(channel->efx, drv, channel->efx->net_dev,

			  "shut down chan %d\n", channel->channel);



		efx_for_each_channel_rx_queue(rx_queue, channel)

			efx_fini_rx_queue(rx_queue);
@@ -572,7 +590,8 @@ static void efx_remove_channel(struct efx_channel *channel) 
	struct efx_tx_queue *tx_queue;

	struct efx_rx_queue *rx_queue;



	EFX_LOG(channel->efx, "destroy chan %d\n", channel->channel);

	netif_dbg(channel->efx, drv, channel->efx->net_dev,

		  "destroy chan %d\n", channel->channel);



	efx_for_each_channel_rx_queue(rx_queue, channel)

		efx_remove_rx_queue(rx_queue);
@@ -623,12 +642,13 @@ void efx_link_status_changed(struct efx_nic *efx) 


	/* Status message for kernel log */

	if (link_state->up) {

		EFX_INFO(efx, "link up at %uMbps %s-duplex (MTU %d)%s\n",

		netif_info(efx, link, efx->net_dev,

			   "link up at %uMbps %s-duplex (MTU %d)%s\n",

			   link_state->speed, link_state->fd ? "full" : "half",

			   efx->net_dev->mtu,

			   (efx->promiscuous ? " [PROMISC]" : ""));

	} else {

		EFX_INFO(efx, "link down\n");

		netif_info(efx, link, efx->net_dev, "link down\n");

	}



}
@@ -732,7 +752,7 @@ static int efx_probe_port(struct efx_nic *efx) 
{

	int rc;



	EFX_LOG(efx, "create port\n");

	netif_dbg(efx, probe, efx->net_dev, "create port\n");



	if (phy_flash_cfg)

		efx->phy_mode = PHY_MODE_SPECIAL;
@@ -746,14 +766,15 @@ static int efx_probe_port(struct efx_nic *efx) 
	if (is_valid_ether_addr(efx->mac_address)) {

		memcpy(efx->net_dev->dev_addr, efx->mac_address, ETH_ALEN);

	} else {

		EFX_ERR(efx, "invalid MAC address %pM\n",

		netif_err(efx, probe, efx->net_dev, "invalid MAC address %pM\n",

			  efx->mac_address);

		if (!allow_bad_hwaddr) {

			rc = -EINVAL;

			goto err;

		}

		random_ether_addr(efx->net_dev->dev_addr);

		EFX_INFO(efx, "using locally-generated MAC %pM\n",

		netif_info(efx, probe, efx->net_dev,

			   "using locally-generated MAC %pM\n",

			   efx->net_dev->dev_addr);

	}
@@ -768,7 +789,7 @@ static int efx_init_port(struct efx_nic *efx) 
{

	int rc;



	EFX_LOG(efx, "init port\n");

	netif_dbg(efx, drv, efx->net_dev, "init port\n");



	mutex_lock(&efx->mac_lock);
@@ -799,7 +820,7 @@ static int efx_init_port(struct efx_nic *efx) 


static void efx_start_port(struct efx_nic *efx)

{

	EFX_LOG(efx, "start port\n");

	netif_dbg(efx, ifup, efx->net_dev, "start port\n");

	BUG_ON(efx->port_enabled);



	mutex_lock(&efx->mac_lock);
@@ -816,7 +837,7 @@ static void efx_start_port(struct efx_nic *efx) 
/* Prevent efx_mac_work() and efx_monitor() from working */

static void efx_stop_port(struct efx_nic *efx)

{

	EFX_LOG(efx, "stop port\n");

	netif_dbg(efx, ifdown, efx->net_dev, "stop port\n");



	mutex_lock(&efx->mac_lock);

	efx->port_enabled = false;
@@ -831,7 +852,7 @@ static void efx_stop_port(struct efx_nic *efx) 


static void efx_fini_port(struct efx_nic *efx)

{

	EFX_LOG(efx, "shut down port\n");

	netif_dbg(efx, drv, efx->net_dev, "shut down port\n");



	if (!efx->port_initialized)

		return;
@@ -845,7 +866,7 @@ static void efx_fini_port(struct efx_nic *efx) 


static void efx_remove_port(struct efx_nic *efx)

{

	EFX_LOG(efx, "destroying port\n");

	netif_dbg(efx, drv, efx->net_dev, "destroying port\n");



	efx->type->remove_port(efx);

}
@@ -863,11 +884,12 @@ static int efx_init_io(struct efx_nic *efx) 
	dma_addr_t dma_mask = efx->type->max_dma_mask;

	int rc;



	EFX_LOG(efx, "initialising I/O\n");

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



	rc = pci_enable_device(pci_dev);

	if (rc) {

		EFX_ERR(efx, "failed to enable PCI device\n");

		netif_err(efx, probe, efx->net_dev,

			  "failed to enable PCI device\n");

		goto fail1;

	}
@@ -885,37 +907,43 @@ static int efx_init_io(struct efx_nic *efx) 
		dma_mask >>= 1;

	}

	if (rc) {

		EFX_ERR(efx, "could not find a suitable DMA mask\n");

		netif_err(efx, probe, efx->net_dev,

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

		goto fail2;

	}

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

	netif_dbg(efx, probe, efx->net_dev,

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

	rc = pci_set_consistent_dma_mask(pci_dev, dma_mask);

	if (rc) {

		/* pci_set_consistent_dma_mask() is not *allowed* to

		 * fail with a mask that pci_set_dma_mask() accepted,

		 * but just in case...

		 */

		EFX_ERR(efx, "failed to set consistent DMA mask\n");

		netif_err(efx, probe, efx->net_dev,

			  "failed to set consistent DMA mask\n");

		goto fail2;

	}



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

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

	if (rc) {

		EFX_ERR(efx, "request for memory BAR failed\n");

		netif_err(efx, probe, efx->net_dev,

			  "request for memory BAR failed\n");

		rc = -EIO;

		goto fail3;

	}

	efx->membase = ioremap_nocache(efx->membase_phys,

				       efx->type->mem_map_size);

	if (!efx->membase) {

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

		netif_err(efx, probe, efx->net_dev,

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

			  (unsigned long long)efx->membase_phys,

			  efx->type->mem_map_size);

		rc = -ENOMEM;

		goto fail4;

	}

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

	netif_dbg(efx, probe, efx->net_dev,

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

		  (unsigned long long)efx->membase_phys,

		  efx->type->mem_map_size, efx->membase);
@@ -933,7 +961,7 @@ static int efx_init_io(struct efx_nic *efx) 


static void efx_fini_io(struct efx_nic *efx)

{

	EFX_LOG(efx, "shutting down I/O\n");

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



	if (efx->membase) {

		iounmap(efx->membase);
@@ -997,9 +1025,11 @@ static void efx_probe_interrupts(struct efx_nic *efx) 
			xentries[i].entry = i;

		rc = pci_enable_msix(efx->pci_dev, xentries, n_channels);

		if (rc > 0) {

			EFX_ERR(efx, "WARNING: Insufficient MSI-X vectors"

			netif_err(efx, drv, efx->net_dev,

				  "WARNING: Insufficient MSI-X vectors"

				  " available (%d < %d).\n", rc, n_channels);

			EFX_ERR(efx, "WARNING: Performance may be reduced.\n");

			netif_err(efx, drv, efx->net_dev,

				  "WARNING: Performance may be reduced.\n");

			EFX_BUG_ON_PARANOID(rc >= n_channels);

			n_channels = rc;

			rc = pci_enable_msix(efx->pci_dev, xentries,
@@ -1023,7 +1053,8 @@ static void efx_probe_interrupts(struct efx_nic *efx) 
		} else {

			/* Fall back to single channel MSI */

			efx->interrupt_mode = EFX_INT_MODE_MSI;

			EFX_ERR(efx, "could not enable MSI-X\n");

			netif_err(efx, drv, efx->net_dev,

				  "could not enable MSI-X\n");

		}

	}
@@ -1036,7 +1067,8 @@ static void efx_probe_interrupts(struct efx_nic *efx) 
		if (rc == 0) {

			efx->channel[0].irq = efx->pci_dev->irq;

		} else {

			EFX_ERR(efx, "could not enable MSI\n");

			netif_err(efx, drv, efx->net_dev,

				  "could not enable MSI\n");

			efx->interrupt_mode = EFX_INT_MODE_LEGACY;

		}

	}
@@ -1090,7 +1122,7 @@ static int efx_probe_nic(struct efx_nic *efx) 
{

	int rc;



	EFX_LOG(efx, "creating NIC\n");

	netif_dbg(efx, probe, efx->net_dev, "creating NIC\n");



	/* Carry out hardware-type specific initialisation */

	rc = efx->type->probe(efx);
@@ -1112,7 +1144,7 @@ static int efx_probe_nic(struct efx_nic *efx) 


static void efx_remove_nic(struct efx_nic *efx)

{

	EFX_LOG(efx, "destroying NIC\n");

	netif_dbg(efx, drv, efx->net_dev, "destroying NIC\n");



	efx_remove_interrupts(efx);

	efx->type->remove(efx);
@@ -1132,14 +1164,14 @@ static int efx_probe_all(struct efx_nic *efx) 
	/* Create NIC */

	rc = efx_probe_nic(efx);

	if (rc) {

		EFX_ERR(efx, "failed to create NIC\n");

		netif_err(efx, probe, efx->net_dev, "failed to create NIC\n");

		goto fail1;

	}



	/* Create port */

	rc = efx_probe_port(efx);

	if (rc) {

		EFX_ERR(efx, "failed to create port\n");

		netif_err(efx, probe, efx->net_dev, "failed to create port\n");

		goto fail2;

	}
@@ -1147,7 +1179,8 @@ static int efx_probe_all(struct efx_nic *efx) 
	efx_for_each_channel(channel, efx) {

		rc = efx_probe_channel(channel);

		if (rc) {

			EFX_ERR(efx, "failed to create channel %d\n",

			netif_err(efx, probe, efx->net_dev,

				  "failed to create channel %d\n",

				  channel->channel);

			goto fail3;

		}
@@ -1344,7 +1377,8 @@ static void efx_monitor(struct work_struct *data) 
	struct efx_nic *efx = container_of(data, struct efx_nic,

					   monitor_work.work);



	EFX_TRACE(efx, "hardware monitor executing on CPU %d\n",

	netif_vdbg(efx, timer, efx->net_dev,

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

		   raw_smp_processor_id());

	BUG_ON(efx->type->monitor == NULL);
@@ -1452,7 +1486,7 @@ static int efx_net_open(struct net_device *net_dev) 
	struct efx_nic *efx = netdev_priv(net_dev);

	EFX_ASSERT_RESET_SERIALISED(efx);



	EFX_LOG(efx, "opening device %s on CPU %d\n", net_dev->name,

	netif_dbg(efx, ifup, efx->net_dev, "opening device on CPU %d\n",

		  raw_smp_processor_id());



	if (efx->state == STATE_DISABLED)
@@ -1478,7 +1512,7 @@ static int efx_net_stop(struct net_device *net_dev) 
{

	struct efx_nic *efx = netdev_priv(net_dev);



	EFX_LOG(efx, "closing %s on CPU %d\n", net_dev->name,

	netif_dbg(efx, ifdown, efx->net_dev, "closing on CPU %d\n",

		  raw_smp_processor_id());



	if (efx->state != STATE_DISABLED) {
@@ -1532,7 +1566,8 @@ static void efx_watchdog(struct net_device *net_dev) 
{

	struct efx_nic *efx = netdev_priv(net_dev);



	EFX_ERR(efx, "TX stuck with port_enabled=%d: resetting channels\n",

	netif_err(efx, tx_err, efx->net_dev,

		  "TX stuck with port_enabled=%d: resetting channels\n",

		  efx->port_enabled);



	efx_schedule_reset(efx, RESET_TYPE_TX_WATCHDOG);
@@ -1552,7 +1587,7 @@ static int efx_change_mtu(struct net_device *net_dev, int new_mtu) 


	efx_stop_all(efx);



	EFX_LOG(efx, "changing MTU to %d\n", new_mtu);

	netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);



	efx_fini_channels(efx);
@@ -1578,7 +1613,8 @@ static int efx_set_mac_address(struct net_device *net_dev, void *data) 
	EFX_ASSERT_RESET_SERIALISED(efx);



	if (!is_valid_ether_addr(new_addr)) {

		EFX_ERR(efx, "invalid ethernet MAC address requested: %pM\n",

		netif_err(efx, drv, efx->net_dev,

			  "invalid ethernet MAC address requested: %pM\n",

			  new_addr);

		return -EINVAL;

	}
@@ -1682,7 +1718,6 @@ static int efx_register_netdev(struct efx_nic *efx) 
	net_dev->watchdog_timeo = 5 * HZ;

	net_dev->irq = efx->pci_dev->irq;

	net_dev->netdev_ops = &efx_netdev_ops;

	SET_NETDEV_DEV(net_dev, &efx->pci_dev->dev);

	SET_ETHTOOL_OPS(net_dev, &efx_ethtool_ops);



	/* Clear MAC statistics */
@@ -1707,7 +1742,8 @@ static int efx_register_netdev(struct efx_nic *efx) 


	rc = device_create_file(&efx->pci_dev->dev, &dev_attr_phy_type);

	if (rc) {

		EFX_ERR(efx, "failed to init net dev attributes\n");

		netif_err(efx, drv, efx->net_dev,

			  "failed to init net dev attributes\n");

		goto fail_registered;

	}
@@ -1715,7 +1751,7 @@ static int efx_register_netdev(struct efx_nic *efx) 


fail_locked:

	rtnl_unlock();

	EFX_ERR(efx, "could not register net dev\n");

	netif_err(efx, drv, efx->net_dev, "could not register net dev\n");

	return rc;



fail_registered:
@@ -1780,7 +1816,7 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok) 


	rc = efx->type->init(efx);

	if (rc) {

		EFX_ERR(efx, "failed to initialise NIC\n");

		netif_err(efx, drv, efx->net_dev, "failed to initialise NIC\n");

		goto fail;

	}
@@ -1792,7 +1828,8 @@ int efx_reset_up(struct efx_nic *efx, enum reset_type method, bool ok) 
		if (rc)

			goto fail;

		if (efx->phy_op->reconfigure(efx))

			EFX_ERR(efx, "could not restore PHY settings\n");

			netif_err(efx, drv, efx->net_dev,

				  "could not restore PHY settings\n");

	}



	efx->mac_op->reconfigure(efx);
@@ -1825,13 +1862,14 @@ int efx_reset(struct efx_nic *efx, enum reset_type method) 
	int rc, rc2;

	bool disabled;



	EFX_INFO(efx, "resetting (%s)\n", RESET_TYPE(method));

	netif_info(efx, drv, efx->net_dev, "resetting (%s)\n",

		   RESET_TYPE(method));



	efx_reset_down(efx, method);



	rc = efx->type->reset(efx, method);

	if (rc) {

		EFX_ERR(efx, "failed to reset hardware\n");

		netif_err(efx, drv, efx->net_dev, "failed to reset hardware\n");

		goto out;

	}
@@ -1856,10 +1894,10 @@ int efx_reset(struct efx_nic *efx, enum reset_type method) 


	if (disabled) {

		dev_close(efx->net_dev);

		EFX_ERR(efx, "has been disabled\n");

		netif_err(efx, drv, efx->net_dev, "has been disabled\n");

		efx->state = STATE_DISABLED;

	} else {

		EFX_LOG(efx, "reset complete\n");

		netif_dbg(efx, drv, efx->net_dev, "reset complete\n");

	}

	return rc;

}
@@ -1877,7 +1915,8 @@ static void efx_reset_work(struct work_struct *data) 
	/* If we're not RUNNING then don't reset. Leave the reset_pending

	 * flag set so that efx_pci_probe_main will be retried */

	if (efx->state != STATE_RUNNING) {

		EFX_INFO(efx, "scheduled reset quenched. NIC not RUNNING\n");

		netif_info(efx, drv, efx->net_dev,

			   "scheduled reset quenched. NIC not RUNNING\n");

		return;

	}
@@ -1891,7 +1930,8 @@ void efx_schedule_reset(struct efx_nic *efx, enum reset_type type) 
	enum reset_type method;



	if (efx->reset_pending != RESET_TYPE_NONE) {

		EFX_INFO(efx, "quenching already scheduled reset\n");

		netif_info(efx, drv, efx->net_dev,

			   "quenching already scheduled reset\n");

		return;

	}
@@ -1915,10 +1955,12 @@ void efx_schedule_reset(struct efx_nic *efx, enum reset_type type) 
	}



	if (method != type)

		EFX_LOG(efx, "scheduling %s reset for %s\n",

		netif_dbg(efx, drv, efx->net_dev,

			  "scheduling %s reset for %s\n",

			  RESET_TYPE(method), RESET_TYPE(type));

	else

		EFX_LOG(efx, "scheduling %s reset\n", RESET_TYPE(method));

		netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",

			  RESET_TYPE(method));



	efx->reset_pending = method;
@@ -2005,6 +2047,7 @@ static int efx_init_struct(struct efx_nic *efx, struct efx_nic_type *type, 
	INIT_WORK(&efx->reset_work, efx_reset_work);

	INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);

	efx->pci_dev = pci_dev;

	efx->msg_enable = debug;

	efx->state = STATE_INIT;

	efx->reset_pending = RESET_TYPE_NONE;

	strlcpy(efx->name, pci_name(pci_dev), sizeof(efx->name));
@@ -2124,7 +2167,7 @@ static void efx_pci_remove(struct pci_dev *pci_dev) 
	efx_pci_remove_main(efx);



	efx_fini_io(efx);

	EFX_LOG(efx, "shutdown successful\n");

	netif_dbg(efx, drv, efx->net_dev, "shutdown successful\n");



	pci_set_drvdata(pci_dev, NULL);

	efx_fini_struct(efx);
@@ -2149,13 +2192,15 @@ static int efx_pci_probe_main(struct efx_nic *efx) 


	rc = efx->type->init(efx);

	if (rc) {

		EFX_ERR(efx, "failed to initialise NIC\n");

		netif_err(efx, probe, efx->net_dev,

			  "failed to initialise NIC\n");

		goto fail3;

	}



	rc = efx_init_port(efx);

	if (rc) {

		EFX_ERR(efx, "failed to initialise port\n");

		netif_err(efx, probe, efx->net_dev,

			  "failed to initialise port\n");

		goto fail4;

	}
@@ -2211,11 +2256,13 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev, 
				   NETIF_F_HIGHDMA | NETIF_F_TSO);

	efx = netdev_priv(net_dev);

	pci_set_drvdata(pci_dev, efx);

	SET_NETDEV_DEV(net_dev, &pci_dev->dev);

	rc = efx_init_struct(efx, type, pci_dev, net_dev);

	if (rc)

		goto fail1;



	EFX_INFO(efx, "Solarflare Communications NIC detected\n");

	netif_info(efx, probe, efx->net_dev,

		   "Solarflare Communications NIC detected\n");



	/* Set up basic I/O (BAR mappings etc) */

	rc = efx_init_io(efx);
@@ -2253,7 +2300,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev, 
	}



	if (rc) {

		EFX_ERR(efx, "Could not reset NIC\n");

		netif_err(efx, probe, efx->net_dev, "Could not reset NIC\n");

		goto fail4;

	}
@@ -2265,7 +2312,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev, 
	if (rc)

		goto fail5;



	EFX_LOG(efx, "initialisation successful\n");

	netif_dbg(efx, probe, efx->net_dev, "initialisation successful\n");



	rtnl_lock();

	efx_mtd_probe(efx); /* allowed to fail */
@@ -2281,7 +2328,7 @@ static int __devinit efx_pci_probe(struct pci_dev *pci_dev, 
	efx_fini_struct(efx);

 fail1:

	WARN_ON(rc > 0);

	EFX_LOG(efx, "initialisation failed. rc=%d\n", rc);

	netif_dbg(efx, drv, efx->net_dev, "initialisation failed. rc=%d\n", rc);

	free_netdev(net_dev);

	return rc;

}

drivers/net/sfc/efx.h

+3 −2
Original line number Diff line number Diff line
@@ -106,7 +106,8 @@ extern unsigned int efx_monitor_interval; 


static inline void efx_schedule_channel(struct efx_channel *channel)

{

	EFX_TRACE(channel->efx, "channel %d scheduling NAPI poll on CPU%d\n",

	netif_vdbg(channel->efx, intr, channel->efx->net_dev,

		   "channel %d scheduling NAPI poll on CPU%d\n",

		   channel->channel, raw_smp_processor_id());

	channel->work_pending = true;

drivers/net/sfc/ethtool.c

+32 −14
Original line number Diff line number Diff line
@@ -218,8 +218,8 @@ int efx_ethtool_set_settings(struct net_device *net_dev, 


	/* GMAC does not support 1000Mbps HD */

	if (ecmd->speed == SPEED_1000 && ecmd->duplex != DUPLEX_FULL) {

		EFX_LOG(efx, "rejecting unsupported 1000Mbps HD"

			" setting\n");

		netif_dbg(efx, drv, efx->net_dev,

			  "rejecting unsupported 1000Mbps HD setting\n");

		return -EINVAL;

	}
@@ -256,6 +256,18 @@ static void efx_ethtool_get_regs(struct net_device *net_dev, 
	efx_nic_get_regs(efx, buf);

}



static u32 efx_ethtool_get_msglevel(struct net_device *net_dev)

{

	struct efx_nic *efx = netdev_priv(net_dev);

	return efx->msg_enable;

}



static void efx_ethtool_set_msglevel(struct net_device *net_dev, u32 msg_enable)

{

	struct efx_nic *efx = netdev_priv(net_dev);

	efx->msg_enable = msg_enable;

}



/**

 * efx_fill_test - fill in an individual self-test entry

 * @test_index:		Index of the test
@@ -553,7 +565,8 @@ static void efx_ethtool_self_test(struct net_device *net_dev, 
	if (!already_up) {

		rc = dev_open(efx->net_dev);

		if (rc) {

			EFX_ERR(efx, "failed opening device.\n");

			netif_err(efx, drv, efx->net_dev,

				  "failed opening device.\n");

			goto fail2;

		}

	}
@@ -565,7 +578,7 @@ static void efx_ethtool_self_test(struct net_device *net_dev, 
	if (!already_up)

		dev_close(efx->net_dev);



	EFX_LOG(efx, "%s %sline self-tests\n",

	netif_dbg(efx, drv, efx->net_dev, "%s %sline self-tests\n",

		  rc == 0 ? "passed" : "failed",

		  (test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");
@@ -693,7 +706,7 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev, 
		return -EOPNOTSUPP;



	if (coalesce->rx_coalesce_usecs || coalesce->tx_coalesce_usecs) {

		EFX_ERR(efx, "invalid coalescing setting. "

		netif_err(efx, drv, efx->net_dev, "invalid coalescing setting. "

			  "Only rx/tx_coalesce_usecs_irq are supported\n");

		return -EOPNOTSUPP;

	}
@@ -706,7 +719,7 @@ static int efx_ethtool_set_coalesce(struct net_device *net_dev, 
	efx_for_each_tx_queue(tx_queue, efx) {

		if ((tx_queue->channel->channel < efx->n_rx_channels) &&

		    tx_usecs) {

			EFX_ERR(efx, "Channel is shared. "

			netif_err(efx, drv, efx->net_dev, "Channel is shared. "

				  "Only RX coalescing may be set\n");

			return -EOPNOTSUPP;

		}
@@ -735,13 +748,15 @@ static int efx_ethtool_set_pauseparam(struct net_device *net_dev, 
		     (pause->autoneg ? EFX_FC_AUTO : 0));



	if ((wanted_fc & EFX_FC_TX) && !(wanted_fc & EFX_FC_RX)) {

		EFX_LOG(efx, "Flow control unsupported: tx ON rx OFF\n");

		netif_dbg(efx, drv, efx->net_dev,

			  "Flow control unsupported: tx ON rx OFF\n");

		rc = -EINVAL;

		goto out;

	}



	if ((wanted_fc & EFX_FC_AUTO) && !efx->link_advertising) {

		EFX_LOG(efx, "Autonegotiation is disabled\n");

		netif_dbg(efx, drv, efx->net_dev,

			  "Autonegotiation is disabled\n");

		rc = -EINVAL;

		goto out;

	}
@@ -772,7 +787,8 @@ static int efx_ethtool_set_pauseparam(struct net_device *net_dev, 
	    (efx->wanted_fc ^ old_fc) & EFX_FC_AUTO) {

		rc = efx->phy_op->reconfigure(efx);

		if (rc) {

			EFX_ERR(efx, "Unable to advertise requested flow "

			netif_err(efx, drv, efx->net_dev,

				  "Unable to advertise requested flow "

				  "control setting\n");

			goto out;

		}
@@ -850,6 +866,8 @@ const struct ethtool_ops efx_ethtool_ops = { 
	.get_drvinfo		= efx_ethtool_get_drvinfo,

	.get_regs_len		= efx_ethtool_get_regs_len,

	.get_regs		= efx_ethtool_get_regs,

	.get_msglevel		= efx_ethtool_get_msglevel,

	.set_msglevel		= efx_ethtool_set_msglevel,

	.nway_reset		= efx_ethtool_nway_reset,

	.get_link		= efx_ethtool_get_link,

	.get_eeprom_len		= efx_ethtool_get_eeprom_len,

drivers/net/sfc/falcon.c

+107 −69

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/sfc/falcon_boards.c

+16 −14
Original line number Diff line number Diff line
@@ -106,7 +106,7 @@ static int efx_check_lm87(struct efx_nic *efx, unsigned mask) 
	alarms1 &= mask;

	alarms2 &= mask >> 8;

	if (alarms1 || alarms2) {

		EFX_ERR(efx,

		netif_err(efx, hw, efx->net_dev,

			  "LM87 detected a hardware failure (status %02x:%02x)"

			  "%s%s\n",

			  alarms1, alarms2,
@@ -243,7 +243,7 @@ static int sfe4001_poweron(struct efx_nic *efx) 
		       (0 << P0_EN_3V3X_LBN) | (0 << P0_EN_5V_LBN) |

		       (0 << P0_EN_1V0X_LBN));

	if (rc != out) {

		EFX_INFO(efx, "power-cycling PHY\n");

		netif_info(efx, hw, efx->net_dev, "power-cycling PHY\n");

		rc = i2c_smbus_write_byte_data(ioexp_client, P0_OUT, out);

		if (rc)

			goto fail_on;
@@ -269,7 +269,8 @@ static int sfe4001_poweron(struct efx_nic *efx) 
		if (rc)

			goto fail_on;



		EFX_INFO(efx, "waiting for DSP boot (attempt %d)...\n", i);

		netif_info(efx, hw, efx->net_dev,

			   "waiting for DSP boot (attempt %d)...\n", i);



		/* In flash config mode, DSP does not turn on AFE, so

		 * just wait 1 second.
@@ -291,7 +292,7 @@ static int sfe4001_poweron(struct efx_nic *efx) 
		}

	}



	EFX_INFO(efx, "timed out waiting for DSP boot\n");

	netif_info(efx, hw, efx->net_dev, "timed out waiting for DSP boot\n");

	rc = -ETIMEDOUT;

fail_on:

	sfe4001_poweroff(efx);
@@ -377,7 +378,7 @@ static void sfe4001_fini(struct efx_nic *efx) 
{

	struct falcon_board *board = falcon_board(efx);



	EFX_INFO(efx, "%s\n", __func__);

	netif_info(efx, drv, efx->net_dev, "%s\n", __func__);



	device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_flash_cfg);

	sfe4001_poweroff(efx);
@@ -461,7 +462,7 @@ static int sfe4001_init(struct efx_nic *efx) 
	if (rc)

		goto fail_on;



	EFX_INFO(efx, "PHY is powered on\n");

	netif_info(efx, hw, efx->net_dev, "PHY is powered on\n");

	return 0;



fail_on:
@@ -493,7 +494,7 @@ static int sfn4111t_check_hw(struct efx_nic *efx) 


static void sfn4111t_fini(struct efx_nic *efx)

{

	EFX_INFO(efx, "%s\n", __func__);

	netif_info(efx, drv, efx->net_dev, "%s\n", __func__);



	device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_flash_cfg);

	i2c_unregister_device(falcon_board(efx)->hwmon_client);
@@ -742,13 +743,14 @@ int falcon_probe_board(struct efx_nic *efx, u16 revision_info) 
			board->type = &board_types[i];



	if (board->type) {

		EFX_INFO(efx, "board is %s rev %c%d\n",

		netif_info(efx, probe, efx->net_dev, "board is %s rev %c%d\n",

			 (efx->pci_dev->subsystem_vendor == EFX_VENDID_SFC)

			 ? board->type->ref_model : board->type->gen_type,

			 'A' + board->major, board->minor);

		return 0;

	} else {

		EFX_ERR(efx, "unknown board type %d\n", type_id);

		netif_err(efx, probe, efx->net_dev, "unknown board type %d\n",

			  type_id);

		return -ENODEV;

	}

}