projects / linux-2.6 / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
p54: correct merge damage from "p54: more SoftLED updates"
[linux-2.6] / drivers / net / netxen / netxen_nic_niu.c
diff --git a/drivers/net/netxen/netxen_nic_niu.c b/drivers/net/netxen/netxen_nic_niu.c
index d852032..5e2698b 100644 (file)
--- a/drivers/net/netxen/netxen_nic_niu.c
+++ b/drivers/net/netxen/netxen_nic_niu.c
@@ -43,8 +43,7 @@ static int phy_lock(struct netxen_adapter *adapter)
        int done = 0, timeout = 0;
 
        while (!done) {
-               done = netxen_nic_reg_read(adapter,
-                               NETXEN_PCIE_REG(PCIE_SEM3_LOCK));
+               done = NXRD32(adapter, NETXEN_PCIE_REG(PCIE_SEM3_LOCK));
                if (done == 1)
                        break;
                if (timeout >= phy_lock_timeout) {
@@ -59,8 +58,7 @@ static int phy_lock(struct netxen_adapter *adapter)
                }
        }
 
-       netxen_crb_writelit_adapter(adapter,
-                       NETXEN_PHY_LOCK_ID, PHY_LOCK_DRIVER);
+       NXWR32(adapter, NETXEN_PHY_LOCK_ID, PHY_LOCK_DRIVER);
        return 0;
 }
 
@@ -105,9 +103,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
         * so it cannot be in reset
         */
 
-       if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                 &mac_cfg0, 4))
-               return -EIO;
+       mac_cfg0 = NXRD32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0));
        if (netxen_gb_get_soft_reset(mac_cfg0)) {
                __u32 temp;
                temp = 0;
@@ -115,9 +111,7 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
                netxen_gb_rx_reset_pb(temp);
                netxen_gb_tx_reset_mac(temp);
                netxen_gb_rx_reset_mac(temp);
-               if (adapter->hw_write_wx(adapter,
-                                          NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                          &temp, 4))
+               if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), temp))
                        return -EIO;
                restore = 1;
        }
@@ -125,43 +119,32 @@ int netxen_niu_gbe_phy_read(struct netxen_adapter *adapter, long reg,
        address = 0;
        netxen_gb_mii_mgmt_reg_addr(address, reg);
        netxen_gb_mii_mgmt_phy_addr(address, phy);
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
-                                  &address, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0), address))
                return -EIO;
        command = 0;            /* turn off any prior activity */
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-                                  &command, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0), command))
                return -EIO;
        /* send read command */
        netxen_gb_mii_mgmt_set_read_cycle(command);
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-                                  &command, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0), command))
                return -EIO;
 
        status = 0;
        do {
-               if (adapter->hw_read_wx(adapter,
-                                         NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
-                                         &status, 4))
-                       return -EIO;
+               status = NXRD32(adapter, NETXEN_NIU_GB_MII_MGMT_INDICATE(0));
                timeout++;
        } while ((netxen_get_gb_mii_mgmt_busy(status)
                  || netxen_get_gb_mii_mgmt_notvalid(status))
                 && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
 
        if (timeout < NETXEN_NIU_PHY_WAITMAX) {
-               if (adapter->hw_read_wx(adapter,
-                                         NETXEN_NIU_GB_MII_MGMT_STATUS(0),
-                                         readval, 4))
-                       return -EIO;
+               *readval = NXRD32(adapter, NETXEN_NIU_GB_MII_MGMT_STATUS(0));
                result = 0;
        } else
                result = -1;
 
        if (restore)
-               if (adapter->hw_write_wx(adapter,
-                                          NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                          &mac_cfg0, 4))
+               if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), mac_cfg0))
                        return -EIO;
        phy_unlock(adapter);
        return result;
@@ -197,9 +180,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
         * cannot be in reset
         */
 
-       if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                 &mac_cfg0, 4))
-               return -EIO;
+       mac_cfg0 = NXRD32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0));
        if (netxen_gb_get_soft_reset(mac_cfg0)) {
                __u32 temp;
                temp = 0;
@@ -208,35 +189,27 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
                netxen_gb_tx_reset_mac(temp);
                netxen_gb_rx_reset_mac(temp);
 
-               if (adapter->hw_write_wx(adapter,
-                                          NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                          &temp, 4))
+               if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), temp))
                        return -EIO;
                restore = 1;
        }
 
        command = 0;            /* turn off any prior activity */
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0),
-                                  &command, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_COMMAND(0), command))
                return -EIO;
 
        address = 0;
        netxen_gb_mii_mgmt_reg_addr(address, reg);
        netxen_gb_mii_mgmt_phy_addr(address, phy);
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0),
-                                  &address, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_ADDR(0), address))
                return -EIO;
 
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MII_MGMT_CTRL(0),
-                                  &val, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_CTRL(0), val))
                return -EIO;
 
        status = 0;
        do {
-               if (adapter->hw_read_wx(adapter,
-                                         NETXEN_NIU_GB_MII_MGMT_INDICATE(0),
-                                         &status, 4))
-                       return -EIO;
+               status = NXRD32(adapter, NETXEN_NIU_GB_MII_MGMT_INDICATE(0));
                timeout++;
        } while ((netxen_get_gb_mii_mgmt_busy(status))
                 && (timeout++ < NETXEN_NIU_PHY_WAITMAX));
@@ -248,9 +221,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
 
        /* restore the state of port 0 MAC in case we tampered with it */
        if (restore)
-               if (adapter->hw_write_wx(adapter,
-                                          NETXEN_NIU_GB_MAC_CONFIG_0(0),
-                                          &mac_cfg0, 4))
+               if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(0), mac_cfg0))
                        return -EIO;
 
        return result;
@@ -258,7 +229,7 @@ int netxen_niu_gbe_phy_write(struct netxen_adapter *adapter, long reg,
 
 int netxen_niu_xgbe_enable_phy_interrupts(struct netxen_adapter *adapter)
 {
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x3f);
+       NXWR32(adapter, NETXEN_NIU_INT_MASK, 0x3f);
        return 0;
 }
 
@@ -281,7 +252,7 @@ int netxen_niu_gbe_enable_phy_interrupts(struct netxen_adapter *adapter)
 
 int netxen_niu_xgbe_disable_phy_interrupts(struct netxen_adapter *adapter)
 {
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_INT_MASK, 0x7f);
+       NXWR32(adapter, NETXEN_NIU_INT_MASK, 0x7f);
        return 0;
 }
 
@@ -315,36 +286,27 @@ static int netxen_niu_gbe_clear_phy_interrupts(struct netxen_adapter *adapter)
 static void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
                                        int port, long enable)
 {
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                   0x80000000);
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                   0x0000f0025);
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
-                                   0xf1ff);
-       netxen_crb_writelit_adapter(adapter,
-                                   NETXEN_NIU_GB0_GMII_MODE + (port << 3), 0);
-       netxen_crb_writelit_adapter(adapter,
-                                   NETXEN_NIU_GB0_MII_MODE + (port << 3), 1);
-       netxen_crb_writelit_adapter(adapter,
-                                   (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
-       netxen_crb_writelit_adapter(adapter,
-                                   NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
+       NXWR32(adapter, NETXEN_NIU_MODE, 0x2);
+       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x80000000);
+       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x0000f0025);
+       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port), 0xf1ff);
+       NXWR32(adapter, NETXEN_NIU_GB0_GMII_MODE + (port << 3), 0);
+       NXWR32(adapter, NETXEN_NIU_GB0_MII_MODE + (port << 3), 1);
+       NXWR32(adapter, (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
+       NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
 
        if (enable) {
                /*
                 * Do NOT enable flow control until a suitable solution for
                 *  shutting down pause frames is found.
                 */
-               netxen_crb_writelit_adapter(adapter,
-                                           NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                           0x5);
+               NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x5);
        }
 
        if (netxen_niu_gbe_enable_phy_interrupts(adapter))
-               printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
+               printk(KERN_ERR "ERROR enabling PHY interrupts\n");
        if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-               printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
+               printk(KERN_ERR "ERROR clearing PHY interrupts\n");
 }
 
 /*
@@ -353,36 +315,27 @@ static void netxen_niu_gbe_set_mii_mode(struct netxen_adapter *adapter,
 static void netxen_niu_gbe_set_gmii_mode(struct netxen_adapter *adapter,
                                         int port, long enable)
 {
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_MODE, 0x2);
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                   0x80000000);
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                   0x0000f0025);
-       netxen_crb_writelit_adapter(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port),
-                                   0xf2ff);
-       netxen_crb_writelit_adapter(adapter,
-                                   NETXEN_NIU_GB0_MII_MODE + (port << 3), 0);
-       netxen_crb_writelit_adapter(adapter,
-                                   NETXEN_NIU_GB0_GMII_MODE + (port << 3), 1);
-       netxen_crb_writelit_adapter(adapter,
-                                   (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
-       netxen_crb_writelit_adapter(adapter,
-                                   NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
+       NXWR32(adapter, NETXEN_NIU_MODE, 0x2);
+       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x80000000);
+       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x0000f0025);
+       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_1(port), 0xf2ff);
+       NXWR32(adapter, NETXEN_NIU_GB0_MII_MODE + (port << 3), 0);
+       NXWR32(adapter, NETXEN_NIU_GB0_GMII_MODE + (port << 3), 1);
+       NXWR32(adapter, (NETXEN_NIU_GB0_HALF_DUPLEX + port * 4), 0);
+       NXWR32(adapter, NETXEN_NIU_GB_MII_MGMT_CONFIG(port), 0x7);
 
        if (enable) {
                /*
                 * Do NOT enable flow control until a suitable solution for
                 *  shutting down pause frames is found.
                 */
-               netxen_crb_writelit_adapter(adapter,
-                                           NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                           0x5);
+               NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), 0x5);
        }
 
        if (netxen_niu_gbe_enable_phy_interrupts(adapter))
-               printk(KERN_ERR PFX "ERROR enabling PHY interrupts\n");
+               printk(KERN_ERR "ERROR enabling PHY interrupts\n");
        if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-               printk(KERN_ERR PFX "ERROR clearing PHY interrupts\n");
+               printk(KERN_ERR "ERROR clearing PHY interrupts\n");
 }
 
 int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
@@ -416,25 +369,20 @@ int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
                         * plugged in.
                         */
 
-                       netxen_crb_writelit_adapter(adapter,
-                                                   NETXEN_NIU_GB_MAC_CONFIG_0
-                                                   (port),
+                       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
                                                    NETXEN_GB_MAC_SOFT_RESET);
-                       netxen_crb_writelit_adapter(adapter,
-                                                   NETXEN_NIU_GB_MAC_CONFIG_0
-                                                   (port),
-                                                   NETXEN_GB_MAC_RESET_PROT_BLK
-                                                   | NETXEN_GB_MAC_ENABLE_TX_RX
-                                                   |
-                                                   NETXEN_GB_MAC_PAUSED_FRMS);
+                       NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
+                                           NETXEN_GB_MAC_RESET_PROT_BLK |
+                                           NETXEN_GB_MAC_ENABLE_TX_RX |
+                                           NETXEN_GB_MAC_PAUSED_FRMS);
                        if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-                               printk(KERN_ERR PFX
+                               printk(KERN_ERR
                                       "ERROR clearing PHY interrupts\n");
                        if (netxen_niu_gbe_enable_phy_interrupts(adapter))
-                               printk(KERN_ERR PFX
+                               printk(KERN_ERR
                                       "ERROR enabling PHY interrupts\n");
                        if (netxen_niu_gbe_clear_phy_interrupts(adapter))
-                               printk(KERN_ERR PFX
+                               printk(KERN_ERR
                                       "ERROR clearing PHY interrupts\n");
                        result = -1;
                }
@@ -447,10 +395,8 @@ int netxen_niu_gbe_init_port(struct netxen_adapter *adapter, int port)
 int netxen_niu_xg_init_port(struct netxen_adapter *adapter, int port)
 {
        if (NX_IS_REVISION_P2(adapter->ahw.revision_id)) {
-               netxen_crb_writelit_adapter(adapter,
-                       NETXEN_NIU_XGE_CONFIG_1+(0x10000*port), 0x1447);
-               netxen_crb_writelit_adapter(adapter,
-                       NETXEN_NIU_XGE_CONFIG_0+(0x10000*port), 0x5);
+               NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_1+(0x10000*port), 0x1447);
+               NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_0+(0x10000*port), 0x5);
        }
 
        return 0;
@@ -473,12 +419,8 @@ static int netxen_niu_macaddr_get(struct netxen_adapter *adapter,
        if ((phy < 0) || (phy > 3))
                return -EINVAL;
 
-       if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy),
-                                 &stationhigh, 4))
-               return -EIO;
-       if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy),
-                                 &stationlow, 4))
-               return -EIO;
+       stationhigh = NXRD32(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy));
+       stationlow = NXRD32(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy));
        ((__le32 *)val)[1] = cpu_to_le32(stationhigh);
        ((__le32 *)val)[0] = cpu_to_le32(stationlow);
 
@@ -507,14 +449,12 @@ int netxen_niu_macaddr_set(struct netxen_adapter *adapter,
                temp[0] = temp[1] = 0;
                memcpy(temp + 2, addr, 2);
                val = le32_to_cpu(*(__le32 *)temp);
-               if (adapter->hw_write_wx(adapter,
-                               NETXEN_NIU_GB_STATION_ADDR_1(phy), &val, 4))
+               if (NXWR32(adapter, NETXEN_NIU_GB_STATION_ADDR_1(phy), val))
                        return -EIO;
 
                memcpy(temp, ((u8 *) addr) + 2, sizeof(__le32));
                val = le32_to_cpu(*(__le32 *)temp);
-               if (adapter->hw_write_wx(adapter,
-                               NETXEN_NIU_GB_STATION_ADDR_0(phy), &val, 4))
+               if (NXWR32(adapter, NETXEN_NIU_GB_STATION_ADDR_0(phy), val))
                        return -2;
 
                netxen_niu_macaddr_get(adapter,
@@ -545,8 +485,7 @@ int netxen_niu_disable_gbe_port(struct netxen_adapter *adapter)
                return -EINVAL;
        mac_cfg0 = 0;
        netxen_gb_soft_reset(mac_cfg0);
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port),
-                                  &mac_cfg0, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_MAC_CONFIG_0(port), mac_cfg0))
                return -EIO;
        return 0;
 }
@@ -564,8 +503,8 @@ int netxen_niu_disable_xg_port(struct netxen_adapter *adapter)
                return -EINVAL;
 
        mac_cfg = 0;
-       if (adapter->hw_write_wx(adapter,
-               NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), &mac_cfg, 4))
+       if (NXWR32(adapter,
+                       NETXEN_NIU_XGE_CONFIG_0 + (0x10000 * port), mac_cfg))
                return -EIO;
        return 0;
 }
@@ -581,9 +520,7 @@ int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
                return -EINVAL;
 
        /* save previous contents */
-       if (adapter->hw_read_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
-                                 &reg, 4))
-               return -EIO;
+       reg = NXRD32(adapter, NETXEN_NIU_GB_DROP_WRONGADDR);
        if (mode == NETXEN_NIU_PROMISC_MODE) {
                switch (port) {
                case 0:
@@ -619,8 +556,7 @@ int netxen_niu_set_promiscuous_mode(struct netxen_adapter *adapter,
                        return -EIO;
                }
        }
-       if (adapter->hw_write_wx(adapter, NETXEN_NIU_GB_DROP_WRONGADDR,
-                                  &reg, 4))
+       if (NXWR32(adapter, NETXEN_NIU_GB_DROP_WRONGADDR, reg))
                return -EIO;
        return 0;
 }
@@ -647,28 +583,24 @@ int netxen_niu_xg_macaddr_set(struct netxen_adapter *adapter,
        case 0:
            memcpy(temp + 2, addr, 2);
            val = le32_to_cpu(*(__le32 *)temp);
-           if (adapter->hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1,
-                               &val, 4))
+           if (NXWR32(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_1, val))
                return -EIO;
 
            memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
            val = le32_to_cpu(*(__le32 *)temp);
-           if (adapter->hw_write_wx(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI,
-                               &val, 4))
+           if (NXWR32(adapter, NETXEN_NIU_XGE_STATION_ADDR_0_HI, val))
                return -EIO;
            break;
 
        case 1:
            memcpy(temp + 2, addr, 2);
            val = le32_to_cpu(*(__le32 *)temp);
-           if (adapter->hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_1,
-                               &val, 4))
+           if (NXWR32(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_1, val))
                return -EIO;
 
            memcpy(&temp, ((u8 *) addr) + 2, sizeof(__le32));
            val = le32_to_cpu(*(__le32 *)temp);
-           if (adapter->hw_write_wx(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_HI,
-                               &val, 4))
+           if (NXWR32(adapter, NETXEN_NIU_XG1_STATION_ADDR_0_HI, val))
                return -EIO;
            break;
 
@@ -689,9 +621,7 @@ int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
        if (port > NETXEN_NIU_MAX_XG_PORTS)
                return -EINVAL;
 
-       if (adapter->hw_read_wx(adapter,
-               NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), &reg, 4))
-                       return -EIO;
+       reg = NXRD32(adapter, NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port));
        if (mode == NETXEN_NIU_PROMISC_MODE)
                reg = (reg | 0x2000UL);
        else
@@ -702,8 +632,7 @@ int netxen_niu_xg_set_promiscuous_mode(struct netxen_adapter *adapter,
        else
                reg = (reg & ~0x1000UL);
 
-       netxen_crb_writelit_adapter(adapter,
-               NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);
+       NXWR32(adapter, NETXEN_NIU_XGE_CONFIG_1 + (0x10000 * port), reg);
 
        return 0;
 }
Making Linux better for my computers