ixgbevf: Make the ethtool register test use accessors
authorMark Rustad <mark.d.rustad@intel.com>
Tue, 4 Mar 2014 03:02:29 +0000 (03:02 +0000)
committerJeff Kirsher <jeffrey.t.kirsher@intel.com>
Fri, 21 Mar 2014 09:11:45 +0000 (02:11 -0700)
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: Mark Rustad <mark.d.rustad@intel.com>
Tested-by: Phil Schmitt <phillip.j.schmitt@intel.com>
Signed-off-by: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
drivers/net/ethernet/intel/ixgbevf/ethtool.c

index f68b78c732a8626c3c011a6d83329c3779fccc51..c769a8d364b6a7429cb00e3cc042c07e3080baf9 100644 (file)
@@ -1,7 +1,7 @@
 /*******************************************************************************
 
   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);                      \
-       }                                                                     \
+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;
 }
 
-#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_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),
-                                               test->mask,
-                                               test->write);
+                               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),
-                                               test->mask,
-                                               test->write);
+                               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),
-                                               test->mask,
-                                               test->write);
+                               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),
-                                               test->mask,
-                                               test->write);
+                               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),
-                                               test->mask,
-                                               test->write);
+                               b = reg_pattern_test(adapter, data,
+                                                    test->reg + 4 + (i * 8),
+                                                    test->mask,
+                                                    test->write);
                                break;
                        }
+                       if (b)
+                               return 1;
                }
                test++;
        }