Merge branch 'for-davem' of git://git.kernel.org/pub/scm/linux/kernel/git/bwh/sfc-next (59bcaed5) · Commits · 戴 / test

drivers/net/ethernet/sfc/ef10.c

+115 −28

Original line number	Diff line number	Diff line
		@@ -14,6 +14,7 @@
		#include "mcdi_pcol.h"
		#include "nic.h"
		#include "workarounds.h"
		#include "selftest.h"
		#include <linux/in.h>
		#include <linux/jhash.h>
		#include <linux/wait.h>
		@@ -277,11 +278,17 @@ fail1:

		static int efx_ef10_free_vis(struct efx_nic *efx)
		{
		int rc = efx_mcdi_rpc(efx, MC_CMD_FREE_VIS, NULL, 0, NULL, 0, NULL);
		MCDI_DECLARE_BUF_OUT_OR_ERR(outbuf, 0);
		size_t outlen;
		int rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FREE_VIS, NULL, 0,
		outbuf, sizeof(outbuf), &outlen);

		/* -EALREADY means nothing to free, so ignore */
		if (rc == -EALREADY)
		rc = 0;
		if (rc)
		efx_mcdi_display_error(efx, MC_CMD_FREE_VIS, 0, outbuf, outlen,
		rc);
		return rc;
		}

		@@ -901,6 +908,7 @@ static int efx_ef10_try_update_nic_stats(struct efx_nic *efx)
		return -EAGAIN;

		/* Update derived statistics */
		efx_nic_fix_nodesc_drop_stat(efx, &stats[EF10_STAT_rx_nodesc_drops]);
		stats[EF10_STAT_rx_good_bytes] =
		stats[EF10_STAT_rx_bytes] -
		stats[EF10_STAT_rx_bytes_minus_good_bytes];
		@@ -1242,7 +1250,6 @@ static void efx_ef10_tx_init(struct efx_tx_queue *tx_queue)

		fail:
		WARN_ON(true);
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
		}

		static void efx_ef10_tx_fini(struct efx_tx_queue *tx_queue)
		@@ -1256,7 +1263,7 @@ static void efx_ef10_tx_fini(struct efx_tx_queue *tx_queue)
		MCDI_SET_DWORD(inbuf, FINI_TXQ_IN_INSTANCE,
		tx_queue->queue);

		rc = efx_mcdi_rpc(efx, MC_CMD_FINI_TXQ, inbuf, sizeof(inbuf),
		rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FINI_TXQ, inbuf, sizeof(inbuf),
		outbuf, sizeof(outbuf), &outlen);

		if (rc && rc != -EALREADY)
		@@ -1265,7 +1272,8 @@ static void efx_ef10_tx_fini(struct efx_tx_queue *tx_queue)
		return;

		fail:
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
		efx_mcdi_display_error(efx, MC_CMD_FINI_TXQ, MC_CMD_FINI_TXQ_IN_LEN,
		outbuf, outlen, rc);
		}

		static void efx_ef10_tx_remove(struct efx_tx_queue *tx_queue)
		@@ -1480,14 +1488,9 @@ static void efx_ef10_rx_init(struct efx_rx_queue *rx_queue)

		rc = efx_mcdi_rpc(efx, MC_CMD_INIT_RXQ, inbuf, inlen,
		outbuf, sizeof(outbuf), &outlen);
		if (rc)
		goto fail;
		WARN_ON(rc);

		return;

		fail:
		WARN_ON(true);
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
		}

		static void efx_ef10_rx_fini(struct efx_rx_queue *rx_queue)
		@@ -1501,7 +1504,7 @@ static void efx_ef10_rx_fini(struct efx_rx_queue *rx_queue)
		MCDI_SET_DWORD(inbuf, FINI_RXQ_IN_INSTANCE,
		efx_rx_queue_index(rx_queue));

		rc = efx_mcdi_rpc(efx, MC_CMD_FINI_RXQ, inbuf, sizeof(inbuf),
		rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FINI_RXQ, inbuf, sizeof(inbuf),
		outbuf, sizeof(outbuf), &outlen);

		if (rc && rc != -EALREADY)
		@@ -1510,7 +1513,8 @@ static void efx_ef10_rx_fini(struct efx_rx_queue *rx_queue)
		return;

		fail:
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
		efx_mcdi_display_error(efx, MC_CMD_FINI_RXQ, MC_CMD_FINI_RXQ_IN_LEN,
		outbuf, outlen, rc);
		}

		static void efx_ef10_rx_remove(struct efx_rx_queue *rx_queue)
		@@ -1647,15 +1651,7 @@ static int efx_ef10_ev_init(struct efx_channel *channel)

		rc = efx_mcdi_rpc(efx, MC_CMD_INIT_EVQ, inbuf, inlen,
		outbuf, sizeof(outbuf), &outlen);
		if (rc)
		goto fail;

		/* IRQ return is ignored */

		return 0;

		fail:
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
		return rc;
		}

		@@ -1669,7 +1665,7 @@ static void efx_ef10_ev_fini(struct efx_channel *channel)

		MCDI_SET_DWORD(inbuf, FINI_EVQ_IN_INSTANCE, channel->channel);

		rc = efx_mcdi_rpc(efx, MC_CMD_FINI_EVQ, inbuf, sizeof(inbuf),
		rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FINI_EVQ, inbuf, sizeof(inbuf),
		outbuf, sizeof(outbuf), &outlen);

		if (rc && rc != -EALREADY)
		@@ -1678,7 +1674,8 @@ static void efx_ef10_ev_fini(struct efx_channel *channel)
		return;

		fail:
		netif_err(efx, hw, efx->net_dev, "%s: failed rc=%d\n", __func__, rc);
		efx_mcdi_display_error(efx, MC_CMD_FINI_EVQ, MC_CMD_FINI_EVQ_IN_LEN,
		outbuf, outlen, rc);
		}

		static void efx_ef10_ev_remove(struct efx_channel *channel)
		@@ -1765,6 +1762,8 @@ static int efx_ef10_handle_rx_event(struct efx_channel *channel,
		((1 << ESF_DZ_RX_DSC_PTR_LBITS_WIDTH) - 1));

		if (n_descs != rx_queue->scatter_n + 1) {
		struct efx_ef10_nic_data *nic_data = efx->nic_data;

		/* detect rx abort */
		if (unlikely(n_descs == rx_queue->scatter_n)) {
		WARN_ON(rx_bytes != 0);
		@@ -1772,10 +1771,13 @@ static int efx_ef10_handle_rx_event(struct efx_channel *channel,
		return 0;
		}

		if (unlikely(rx_queue->scatter_n != 0)) {
		/* Scattered packet completions cannot be
		* merged, so something has gone wrong.
		/* Check that RX completion merging is valid, i.e.
		* the current firmware supports it and this is a
		* non-scattered packet.
		*/
		if (!(nic_data->datapath_caps &
		(1 << MC_CMD_GET_CAPABILITIES_OUT_RX_BATCHING_LBN)) \|\|
		rx_queue->scatter_n != 0 \|\| rx_cont) {
		efx_ef10_handle_rx_bad_lbits(
		rx_queue, next_ptr_lbits,
		(rx_queue->removed_count +
		@@ -1901,7 +1903,7 @@ static void efx_ef10_handle_driver_generated_event(struct efx_channel *channel,
		* events, so efx_process_channel() won't refill the
		* queue. Refill it here
		*/
		efx_fast_push_rx_descriptors(&channel->rx_queue);
		efx_fast_push_rx_descriptors(&channel->rx_queue, true);
		break;
		default:
		netif_err(efx, hw, efx->net_dev,
		@@ -2257,6 +2259,8 @@ static int efx_ef10_filter_push(struct efx_nic *efx,
		outbuf, sizeof(outbuf), NULL);
		if (rc == 0)
		*handle = MCDI_QWORD(outbuf, FILTER_OP_OUT_HANDLE);
		if (rc == -ENOSPC)
		rc = -EBUSY; /* to match efx_farch_filter_insert() */
		return rc;
		}

		@@ -3195,6 +3199,87 @@ static int efx_ef10_mac_reconfigure(struct efx_nic *efx)
		return efx_mcdi_set_mac(efx);
		}

		static int efx_ef10_start_bist(struct efx_nic *efx, u32 bist_type)
		{
		MCDI_DECLARE_BUF(inbuf, MC_CMD_START_BIST_IN_LEN);

		MCDI_SET_DWORD(inbuf, START_BIST_IN_TYPE, bist_type);
		return efx_mcdi_rpc(efx, MC_CMD_START_BIST, inbuf, sizeof(inbuf),
		NULL, 0, NULL);
		}

		/* MC BISTs follow a different poll mechanism to phy BISTs.
		* The BIST is done in the poll handler on the MC, and the MCDI command
		* will block until the BIST is done.
		*/
		static int efx_ef10_poll_bist(struct efx_nic *efx)
		{
		int rc;
		MCDI_DECLARE_BUF(outbuf, MC_CMD_POLL_BIST_OUT_LEN);
		size_t outlen;
		u32 result;

		rc = efx_mcdi_rpc(efx, MC_CMD_POLL_BIST, NULL, 0,
		outbuf, sizeof(outbuf), &outlen);
		if (rc != 0)
		return rc;

		if (outlen < MC_CMD_POLL_BIST_OUT_LEN)
		return -EIO;

		result = MCDI_DWORD(outbuf, POLL_BIST_OUT_RESULT);
		switch (result) {
		case MC_CMD_POLL_BIST_PASSED:
		netif_dbg(efx, hw, efx->net_dev, "BIST passed.\n");
		return 0;
		case MC_CMD_POLL_BIST_TIMEOUT:
		netif_err(efx, hw, efx->net_dev, "BIST timed out\n");
		return -EIO;
		case MC_CMD_POLL_BIST_FAILED:
		netif_err(efx, hw, efx->net_dev, "BIST failed.\n");
		return -EIO;
		default:
		netif_err(efx, hw, efx->net_dev,
		"BIST returned unknown result %u", result);
		return -EIO;
		}
		}

		static int efx_ef10_run_bist(struct efx_nic *efx, u32 bist_type)
		{
		int rc;

		netif_dbg(efx, drv, efx->net_dev, "starting BIST type %u\n", bist_type);

		rc = efx_ef10_start_bist(efx, bist_type);
		if (rc != 0)
		return rc;

		return efx_ef10_poll_bist(efx);
		}

		static int
		efx_ef10_test_chip(struct efx_nic efx, struct efx_self_tests tests)
		{
		int rc, rc2;

		efx_reset_down(efx, RESET_TYPE_WORLD);

		rc = efx_mcdi_rpc(efx, MC_CMD_ENABLE_OFFLINE_BIST,
		NULL, 0, NULL, 0, NULL);
		if (rc != 0)
		goto out;

		tests->memory = efx_ef10_run_bist(efx, MC_CMD_MC_MEM_BIST) ? -1 : 1;
		tests->registers = efx_ef10_run_bist(efx, MC_CMD_REG_BIST) ? -1 : 1;

		rc = efx_mcdi_reset(efx, RESET_TYPE_WORLD);

		out:
		rc2 = efx_reset_up(efx, RESET_TYPE_WORLD, rc == 0);
		return rc ? rc : rc2;
		}

		#ifdef CONFIG_SFC_MTD

		struct efx_ef10_nvram_type_info {
		@@ -3213,6 +3298,7 @@ static const struct efx_ef10_nvram_type_info efx_ef10_nvram_types[] = {
		{ NVRAM_PARTITION_TYPE_EXPROM_CONFIG_PORT1, 0, 1, "sfc_exp_rom_cfg" },
		{ NVRAM_PARTITION_TYPE_EXPROM_CONFIG_PORT2, 0, 2, "sfc_exp_rom_cfg" },
		{ NVRAM_PARTITION_TYPE_EXPROM_CONFIG_PORT3, 0, 3, "sfc_exp_rom_cfg" },
		{ NVRAM_PARTITION_TYPE_LICENSE, 0, 0, "sfc_license" },
		{ NVRAM_PARTITION_TYPE_PHY_MIN, 0xff, 0, "sfc_phy_fw" },
		};

		@@ -3336,6 +3422,7 @@ const struct efx_nic_type efx_hunt_a0_nic_type = {
		.describe_stats = efx_ef10_describe_stats,
		.update_stats = efx_ef10_update_stats,
		.start_stats = efx_mcdi_mac_start_stats,
		.pull_stats = efx_mcdi_mac_pull_stats,
		.stop_stats = efx_mcdi_mac_stop_stats,
		.set_id_led = efx_mcdi_set_id_led,
		.push_irq_moderation = efx_ef10_push_irq_moderation,
		@@ -3345,7 +3432,7 @@ const struct efx_nic_type efx_hunt_a0_nic_type = {
		.get_wol = efx_ef10_get_wol,
		.set_wol = efx_ef10_set_wol,
		.resume_wol = efx_port_dummy_op_void,
		/* TODO: test_chip */
		.test_chip = efx_ef10_test_chip,
		.test_nvram = efx_mcdi_nvram_test_all,
		.mcdi_request = efx_ef10_mcdi_request,
		.mcdi_poll_response = efx_ef10_mcdi_poll_response,

drivers/net/ethernet/sfc/efx.c

+63 −21

Original line number	Diff line number	Diff line
		@@ -83,6 +83,7 @@ const char *const efx_reset_type_names[] = {
		[RESET_TYPE_DMA_ERROR] = "DMA_ERROR",
		[RESET_TYPE_TX_SKIP] = "TX_SKIP",
		[RESET_TYPE_MC_FAILURE] = "MC_FAILURE",
		[RESET_TYPE_MC_BIST] = "MC_BIST",
		};

		/* Reset workqueue. If any NIC has a hardware failure then a reset will be
		@@ -91,6 +92,12 @@ const char *const efx_reset_type_names[] = {
		*/
		static struct workqueue_struct *reset_workqueue;

		/* 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
		@@ -246,7 +253,7 @@ static int efx_process_channel(struct efx_channel *channel, int budget)
		efx_channel_get_rx_queue(channel);

		efx_rx_flush_packet(channel);
		efx_fast_push_rx_descriptors(rx_queue);
		efx_fast_push_rx_descriptors(rx_queue, true);
		}

		return spent;
		@@ -585,7 +592,7 @@ static void efx_start_datapath(struct efx_nic *efx)
		EFX_MAX_FRAME_LEN(efx->net_dev->mtu) +
		efx->type->rx_buffer_padding);
		rx_buf_len = (sizeof(struct efx_rx_page_state) +
		NET_IP_ALIGN + efx->rx_dma_len);
		efx->rx_ip_align + efx->rx_dma_len);
		if (rx_buf_len <= PAGE_SIZE) {
		efx->rx_scatter = efx->type->always_rx_scatter;
		efx->rx_buffer_order = 0;
		@@ -639,12 +646,16 @@ static void efx_start_datapath(struct efx_nic *efx)
		efx_for_each_channel_rx_queue(rx_queue, channel) {
		efx_init_rx_queue(rx_queue);
		atomic_inc(&efx->active_queues);
		efx_nic_generate_fill_event(rx_queue);
		efx_stop_eventq(channel);
		efx_fast_push_rx_descriptors(rx_queue, false);
		efx_start_eventq(channel);
		}

		WARN_ON(channel->rx_pkt_n_frags);
		}

		efx_ptp_start_datapath(efx);

		if (netif_device_present(efx->net_dev))
		netif_tx_wake_all_queues(efx->net_dev);
		}
		@@ -659,6 +670,8 @@ static void efx_stop_datapath(struct efx_nic *efx)
		EFX_ASSERT_RESET_SERIALISED(efx);
		BUG_ON(efx->port_enabled);

		efx_ptp_stop_datapath(efx);

		/* Stop RX refill */
		efx_for_each_channel(channel, efx) {
		efx_for_each_channel_rx_queue(rx_queue, channel)
		@@ -1047,18 +1060,23 @@ static void efx_start_port(struct efx_nic *efx)
		mutex_lock(&efx->mac_lock);
		efx->port_enabled = true;

		/* efx_mac_work() might have been scheduled after efx_stop_port(),
		* and then cancelled by efx_flush_all() */
		/* Ensure MAC ingress/egress is enabled */
		efx->type->reconfigure_mac(efx);

		mutex_unlock(&efx->mac_lock);
		}

		/* Prevent efx_mac_work() and efx_monitor() from working */
		/* Cancel work for MAC reconfiguration, periodic hardware monitoring
		* and the async self-test, wait for them to finish and prevent them
		* being scheduled again. This doesn't cover online resets, which
		* should only be cancelled when removing the device.
		*/
		static void efx_stop_port(struct efx_nic *efx)
		{
		netif_dbg(efx, ifdown, efx->net_dev, "stop port\n");

		EFX_ASSERT_RESET_SERIALISED(efx);

		mutex_lock(&efx->mac_lock);
		efx->port_enabled = false;
		mutex_unlock(&efx->mac_lock);
		@@ -1066,6 +1084,10 @@ static void efx_stop_port(struct efx_nic *efx)
		/* Serialise against efx_set_multicast_list() */
		netif_addr_lock_bh(efx->net_dev);
		netif_addr_unlock_bh(efx->net_dev);

		cancel_delayed_work_sync(&efx->monitor_work);
		efx_selftest_async_cancel(efx);
		cancel_work_sync(&efx->mac_work);
		}

		static void efx_fini_port(struct efx_nic *efx)
		@@ -1671,18 +1693,10 @@ static void efx_start_all(struct efx_nic *efx)
		}

		efx->type->start_stats(efx);
		}

		/* Flush all delayed work. Should only be called when no more delayed work
		* will be scheduled. This doesn't flush pending online resets (efx_reset),
		* since we're holding the rtnl_lock at this point. */
		static void efx_flush_all(struct efx_nic *efx)
		{
		/* Make sure the hardware monitor and event self-test are stopped */
		cancel_delayed_work_sync(&efx->monitor_work);
		efx_selftest_async_cancel(efx);
		/* Stop scheduled port reconfigurations */
		cancel_work_sync(&efx->mac_work);
		efx->type->pull_stats(efx);
		spin_lock_bh(&efx->stats_lock);
		efx->type->update_stats(efx, NULL, NULL);
		spin_unlock_bh(&efx->stats_lock);
		}

		/* Quiesce the hardware and software data path, and regular activity
		@@ -1698,12 +1712,16 @@ static void efx_stop_all(struct efx_nic *efx)
		if (!efx->port_enabled)
		return;

		/* update stats before we go down so we can accurately count
		* rx_nodesc_drops
		*/
		efx->type->pull_stats(efx);
		spin_lock_bh(&efx->stats_lock);
		efx->type->update_stats(efx, NULL, NULL);
		spin_unlock_bh(&efx->stats_lock);
		efx->type->stop_stats(efx);
		efx_stop_port(efx);

		/* Flush efx_mac_work(), refill_workqueue, monitor_work */
		efx_flush_all(efx);

		/* Stop the kernel transmit interface. This is only valid if
		* the device is stopped or detached; otherwise the watchdog
		* may fire immediately.
		@@ -2385,6 +2403,24 @@ int efx_try_recovery(struct efx_nic *efx)
		return 0;
		}

		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.
		*/
		@@ -2397,6 +2433,9 @@ static void efx_reset_work(struct work_struct *data)
		pending = ACCESS_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))
		@@ -2435,6 +2474,7 @@ void efx_schedule_reset(struct efx_nic *efx, enum reset_type type)
		case RESET_TYPE_WORLD:
		case RESET_TYPE_DISABLE:
		case RESET_TYPE_RECOVER_OR_DISABLE:
		case RESET_TYPE_MC_BIST:
		method = type;
		netif_dbg(efx, drv, efx->net_dev, "scheduling %s reset\n",
		RESET_TYPE(method));
		@@ -2542,6 +2582,8 @@ static int efx_init_struct(struct efx_nic *efx,

		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;
		spin_lock_init(&efx->stats_lock);

drivers/net/ethernet/sfc/efx.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -37,7 +37,7 @@ int efx_probe_rx_queue(struct efx_rx_queue *rx_queue);
		void efx_remove_rx_queue(struct efx_rx_queue *rx_queue);
		void efx_init_rx_queue(struct efx_rx_queue *rx_queue);
		void efx_fini_rx_queue(struct efx_rx_queue *rx_queue);
		void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue);
		void efx_fast_push_rx_descriptors(struct efx_rx_queue *rx_queue, bool atomic);
		void efx_rx_slow_fill(unsigned long context);
		void __efx_rx_packet(struct efx_channel *channel);
		void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,

drivers/net/ethernet/sfc/enum.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -165,6 +165,7 @@ enum reset_type {
		RESET_TYPE_DMA_ERROR,
		RESET_TYPE_TX_SKIP,
		RESET_TYPE_MC_FAILURE,
		RESET_TYPE_MC_BIST,
		RESET_TYPE_MAX,
		};

drivers/net/ethernet/sfc/ethtool.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -318,6 +318,8 @@ static int efx_ethtool_fill_self_tests(struct efx_nic *efx,
		"eventq.int", NULL);
		}

		efx_fill_test(n++, strings, data, &tests->memory,
		"core", 0, "memory", NULL);
		efx_fill_test(n++, strings, data, &tests->registers,
		"core", 0, "registers", NULL);

Admin message