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

Commit 388b2e4c authored by Mark Rustad's avatar Mark Rustad Committed by Jeff Kirsher
Browse files

ixgbevf: Make the ethtool register test use accessors 



Make the ethtool register test use the normal register accessor
functions. Also eliminate macros used for calling register test
functions to make error exits clearer.

Signed-off-by: default avatarMark Rustad <mark.d.rustad@intel.com>
Tested-by: default avatarPhil Schmitt <phillip.j.schmitt@intel.com>
Signed-off-by: default avatarJeff Kirsher <jeffrey.t.kirsher@intel.com>
parent 06380db6

drivers/net/ethernet/intel/ixgbevf/ethtool.c

+67 −52
Original line number Diff line number Diff line 
/*******************************************************************************



  Intel 82599 Virtual Function driver

  Copyright(c) 1999 - 2012 Intel Corporation.

  Copyright(c) 1999 - 2014 Intel Corporation.



  This program is free software; you can redistribute it and/or modify it

  under the terms and conditions of the GNU General Public License,
@@ -530,41 +530,47 @@ static const u32 register_test_patterns[] = { 
	0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF

};



#define REG_PATTERN_TEST(R, M, W)                                             \

{                                                                             \

	u32 pat, val, before;                                                 \

	for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) {      \

		before = readl(adapter->hw.hw_addr + R);                      \

		writel((register_test_patterns[pat] & W),                     \

		       (adapter->hw.hw_addr + R));                            \

		val = readl(adapter->hw.hw_addr + R);                         \

		if (val != (register_test_patterns[pat] & W & M)) {           \

			hw_dbg(&adapter->hw,                                  \

			"pattern test reg %04X failed: got "                  \

			"0x%08X expected 0x%08X\n",                           \

			R, val, (register_test_patterns[pat] & W & M));       \

			*data = R;                                            \

			writel(before, adapter->hw.hw_addr + R);              \

			return 1;                                             \

		}                                                             \

		writel(before, adapter->hw.hw_addr + R);                      \

	}                                                                     \

}



#define REG_SET_AND_CHECK(R, M, W)                                            \

{                                                                             \

	u32 val, before;                                                      \

	before = readl(adapter->hw.hw_addr + R);                              \

	writel((W & M), (adapter->hw.hw_addr + R));                           \

	val = readl(adapter->hw.hw_addr + R);                                 \

	if ((W & M) != (val & M)) {                                           \

		pr_err("set/check reg %04X test failed: got 0x%08X expected " \

		       "0x%08X\n", R, (val & M), (W & M));                    \

		*data = R;                                                    \

		writel(before, (adapter->hw.hw_addr + R));                    \

		return 1;                                                     \

	}                                                                     \

	writel(before, (adapter->hw.hw_addr + R));                            \

static bool reg_pattern_test(struct ixgbevf_adapter *adapter, u64 *data,

			     int reg, u32 mask, u32 write)

{

	u32 pat, val, before;



	for (pat = 0; pat < ARRAY_SIZE(register_test_patterns); pat++) {

		before = ixgbe_read_reg(&adapter->hw, reg);

		ixgbe_write_reg(&adapter->hw, reg,

				register_test_patterns[pat] & write);

		val = ixgbe_read_reg(&adapter->hw, reg);

		if (val != (register_test_patterns[pat] & write & mask)) {

			hw_dbg(&adapter->hw,

			       "pattern test reg %04X failed: got 0x%08X expected 0x%08X\n",

			       reg, val,

			       register_test_patterns[pat] & write & mask);

			*data = reg;

			ixgbe_write_reg(&adapter->hw, reg, before);

			return true;

		}

		ixgbe_write_reg(&adapter->hw, reg, before);

	}

	return false;

}



static bool reg_set_and_check(struct ixgbevf_adapter *adapter, u64 *data,

			      int reg, u32 mask, u32 write)

{

	u32 val, before;



	before = ixgbe_read_reg(&adapter->hw, reg);

	ixgbe_write_reg(&adapter->hw, reg, write & mask);

	val = ixgbe_read_reg(&adapter->hw, reg);

	if ((write & mask) != (val & mask)) {

		pr_err("set/check reg %04X test failed: got 0x%08X expected 0x%08X\n",

		       reg, (val & mask), write & mask);

		*data = reg;

		ixgbe_write_reg(&adapter->hw, reg, before);

		return true;

	}

	ixgbe_write_reg(&adapter->hw, reg, before);

	return false;

}



static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data)
@@ -580,38 +586,47 @@ static int ixgbevf_reg_test(struct ixgbevf_adapter *adapter, u64 *data) 
	 */

	while (test->reg) {

		for (i = 0; i < test->array_len; i++) {

			bool b = false;



			switch (test->test_type) {

			case PATTERN_TEST:

				REG_PATTERN_TEST(test->reg + (i * 0x40),

				b = reg_pattern_test(adapter, data,

						     test->reg + (i * 0x40),

						     test->mask,

						     test->write);

				break;

			case SET_READ_TEST:

				REG_SET_AND_CHECK(test->reg + (i * 0x40),

				b = reg_set_and_check(adapter, data,

						      test->reg + (i * 0x40),

						      test->mask,

						      test->write);

				break;

			case WRITE_NO_TEST:

				writel(test->write,

				       (adapter->hw.hw_addr + test->reg)

				       + (i * 0x40));

				ixgbe_write_reg(&adapter->hw,

						  test->reg + (i * 0x40),

						  test->write);

				break;

			case TABLE32_TEST:

				REG_PATTERN_TEST(test->reg + (i * 4),

				b = reg_pattern_test(adapter, data,

						     test->reg + (i * 4),

						     test->mask,

						     test->write);

				break;

			case TABLE64_TEST_LO:

				REG_PATTERN_TEST(test->reg + (i * 8),

				b = reg_pattern_test(adapter, data,

						     test->reg + (i * 8),

						     test->mask,

						     test->write);

				break;

			case TABLE64_TEST_HI:

				REG_PATTERN_TEST((test->reg + 4) + (i * 8),

				b = reg_pattern_test(adapter, data,

						     test->reg + 4 + (i * 8),

						     test->mask,

						     test->write);

				break;

			}

			if (b)

				return 1;

		}

		test++;

	}