Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=7e64300a0f335e443aa39ee477c541e34a69ae52
Commit:     7e64300a0f335e443aa39ee477c541e34a69ae52
Parent:     ef90e4eca9fcade05dd03f853df75cf459a75422
Author:     Joe Perches <[EMAIL PROTECTED]>
AuthorDate: Tue Nov 13 20:52:05 2007 -0800
Committer:  David S. Miller <[EMAIL PROTECTED]>
CommitDate: Mon Jan 28 15:03:50 2008 -0800

    [E1000]: Convert regtest macro's to functions
    
    Minimal macro to function conversion in e1000_ethtool.c
    
    Adds functions reg_pattern_test and reg_set_and_check
    Changes REG_PATTERN_TEST and REG_SET_AND_CHECK macros
    to call these functions.
    
    Saves ~2.5KB
    
    Compiled x86, untested (no hardware)
    
    old:
    
    $ size drivers/net/e1000/e1000_ethtool.o
       text    data     bss     dec     hex filename
      16778       0       0   16778    418a drivers/net/e1000/e1000_ethtool.o
    
    new:
    
    $ size drivers/net/e1000/e1000_ethtool.o
       text    data     bss     dec     hex filename
      14128       0       0   14128    3730 drivers/net/e1000/e1000_ethtool.o
    
    Signed-off-by: Joe Perches <[EMAIL PROTECTED]>
    Signed-off-by: Auke Kok <[EMAIL PROTECTED]>
    Signed-off-by: David S. Miller <[EMAIL PROTECTED]>
---
 drivers/net/e1000/e1000_ethtool.c |   84 ++++++++++++++++++++++++-------------
 1 files changed, 55 insertions(+), 29 deletions(-)

diff --git a/drivers/net/e1000/e1000_ethtool.c 
b/drivers/net/e1000/e1000_ethtool.c
index 2e44191..2280818 100644
--- a/drivers/net/e1000/e1000_ethtool.c
+++ b/drivers/net/e1000/e1000_ethtool.c
@@ -728,39 +728,65 @@ err_setup:
        return err;
 }
 
-#define REG_PATTERN_TEST(R, M, W)                                              
\
-{                                                                              
\
-       uint32_t pat, val;                                                     \
-       const uint32_t test[] =                                                \
-               {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};              \
-       for (pat = 0; pat < ARRAY_SIZE(test); pat++) {                         \
-               E1000_WRITE_REG(&adapter->hw, R, (test[pat] & W));             \
-               val = E1000_READ_REG(&adapter->hw, R);                         \
-               if (val != (test[pat] & W & M)) {                              \
-                       DPRINTK(DRV, ERR, "pattern test reg %04X failed: got " \
-                               "0x%08X expected 0x%08X\n",                    \
-                               E1000_##R, val, (test[pat] & W & M));          \
-                       *data = (adapter->hw.mac_type < e1000_82543) ?         \
-                               E1000_82542_##R : E1000_##R;                   \
-                       return 1;                                              \
-               }                                                              \
-       }                                                                      \
+static bool reg_pattern_test(struct e1000_adapter *adapter, uint64_t *data,
+                            int reg, uint32_t mask, uint32_t write)
+{
+       static const uint32_t test[] =
+               {0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF};
+       uint8_t __iomem *address = adapter->hw.hw_addr + reg;
+       uint32_t read;
+       int i;
+
+       for (i = 0; i < ARRAY_SIZE(test); i++) {
+               writel(write & test[i], address);
+               read = readl(address);
+               if (read != (write & test[i] & mask)) {
+                       DPRINTK(DRV, ERR, "pattern test reg %04X failed: "
+                               "got 0x%08X expected 0x%08X\n",
+                               reg, read, (write & test[i] & mask));
+                       *data = reg;
+                       return true;
+               }
+       }
+       return false;
 }
 
-#define REG_SET_AND_CHECK(R, M, W)                                             
\
-{                                                                              
\
-       uint32_t val;                                                          \
-       E1000_WRITE_REG(&adapter->hw, R, W & M);                               \
-       val = E1000_READ_REG(&adapter->hw, R);                                 \
-       if ((W & M) != (val & M)) {                                            \
-               DPRINTK(DRV, ERR, "set/check reg %04X test failed: got 0x%08X "\
-                       "expected 0x%08X\n", E1000_##R, (val & M), (W & M));   \
-               *data = (adapter->hw.mac_type < e1000_82543) ?                 \
-                       E1000_82542_##R : E1000_##R;                           \
-               return 1;                                                      \
-       }                                                                      \
+static bool reg_set_and_check(struct e1000_adapter *adapter, uint64_t *data,
+                             int reg, uint32_t mask, uint32_t write)
+{
+       uint8_t __iomem *address = adapter->hw.hw_addr + reg;
+       uint32_t read;
+
+       writel(write & mask, address);
+       read = readl(address);
+       if ((read & mask) != (write & mask)) {
+               DPRINTK(DRV, ERR, "set/check reg %04X test failed: "
+                       "got 0x%08X expected 0x%08X\n",
+                       reg, (read & mask), (write & mask));
+               *data = reg;
+               return true;
+       }
+       return false;
 }
 
+#define REG_PATTERN_TEST(reg, mask, write)                          \
+       do {                                                         \
+               if (reg_pattern_test(adapter, data,                  \
+                            (adapter->hw.mac_type >= e1000_82543)   \
+                            ? E1000_##reg : E1000_82542_##reg,      \
+                            mask, write))                           \
+                       return 1;                                    \
+       } while (0)
+
+#define REG_SET_AND_CHECK(reg, mask, write)                         \
+       do {                                                         \
+               if (reg_set_and_check(adapter, data,                 \
+                             (adapter->hw.mac_type >= e1000_82543)  \
+                             ? E1000_##reg : E1000_82542_##reg,     \
+                             mask, write))                          \
+                       return 1;                                    \
+       } while (0)
+
 static int
 e1000_reg_test(struct e1000_adapter *adapter, uint64_t *data)
 {
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to