Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking updates from David Miller:

 1) Seccomp BPF filters can now be JIT'd, from Alexei Starovoitov.

 2) Multiqueue support in xen-netback and xen-netfront, from Andrew J
    Benniston.

 3) Allow tweaking of aggregation settings in cdc_ncm driver, from Bjørn
    Mork.

 4) BPF now has a "random" opcode, from Chema Gonzalez.

 5) Add more BPF documentation and improve test framework, from Daniel
    Borkmann.

 6) Support TCP fastopen over ipv6, from Daniel Lee.

 7) Add software TSO helper functions and use them to support software
    TSO in mvneta and mv643xx_eth drivers.  From Ezequiel Garcia.

 8) Support software TSO in fec driver too, from Nimrod Andy.

 9) Add Broadcom SYSTEMPORT driver, from Florian Fainelli.

10) Handle broadcasts more gracefully over macvlan when there are large
    numbers of interfaces configured, from Herbert Xu.

11) Allow more control over fwmark used for non-socket based responses,
    from Lorenzo Colitti.

12) Do TCP congestion window limiting based upon measurements, from Neal
    Cardwell.

13) Support busy polling in SCTP, from Neal Horman.

14) Allow RSS key to be configured via ethtool, from Venkata Duvvuru.

15) Bridge promisc mode handling improvements from Vlad Yasevich.

16) Don't use inetpeer entries to implement ID generation any more, it
    performs poorly, from Eric Dumazet.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1522 commits)
  rtnetlink: fix userspace API breakage for iproute2 < v3.9.0
  tcp: fixing TLP's FIN recovery
  net: fec: Add software TSO support
  net: fec: Add Scatter/gather support
  net: fec: Increase buffer descriptor entry number
  net: fec: Factorize feature setting
  net: fec: Enable IP header hardware checksum
  net: fec: Factorize the .xmit transmit function
  bridge: fix compile error when compiling without IPv6 support
  bridge: fix smatch warning / potential null pointer dereference
  via-rhine: fix full-duplex with autoneg disable
  bnx2x: Enlarge the dorq threshold for VFs
  bnx2x: Check for UNDI in uncommon branch
  bnx2x: Fix 1G-baseT link
  bnx2x: Fix link for KR with swapped polarity lane
  sctp: Fix sk_ack_backlog wrap-around problem
  net/core: Add VF link state control policy
  net/fsl: xgmac_mdio is dependent on OF_MDIO
  net/fsl: Make xgmac_mdio read error message useful
  net_sched: drr: warn when qdisc is not work conserving
  ...

1 files changed, 66 insertions, 68 deletions

diff --git a/drivers/net/ethernet/intel/igb/e1000_i210.c b/drivers/net/ethernet/intel/igb/e1000_i210.c
index f67f8a170b90..337161f440dd 100644
--- a/drivers/net/ethernet/intel/igb/e1000_i210.c
+++ b/drivers/net/ethernet/intel/igb/e1000_i210.c
@@ -1,28 +1,25 @@
-/*******************************************************************************
-
-  Intel(R) Gigabit Ethernet Linux driver
-  Copyright(c) 2007-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,
-  version 2, as published by the Free Software Foundation.
-
-  This program is distributed in the hope it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
-  more details.
-
-  You should have received a copy of the GNU General Public License along with
-  this program; if not, see <http://www.gnu.org/licenses/>.
-
-  The full GNU General Public License is included in this distribution in
-  the file called "COPYING".
-
-  Contact Information:
-  e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
-  Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
-
-******************************************************************************/
+/* Intel(R) Gigabit Ethernet Linux driver
+ * Copyright(c) 2007-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,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * The full GNU General Public License is included in this distribution in
+ * the file called "COPYING".
+ *
+ * Contact Information:
+ * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>
+ * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
+ */
 
 /* e1000_i210
  * e1000_i211
@@ -100,7 +97,7 @@ static s32 igb_get_hw_semaphore_i210(struct e1000_hw *hw)
                 return -E1000_ERR_NVM;
         }
 
-        return E1000_SUCCESS;
+        return 0;
 }
 
 /**
@@ -142,7 +139,7 @@ s32 igb_acquire_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
         u32 swfw_sync;
         u32 swmask = mask;
         u32 fwmask = mask << 16;
-        s32 ret_val = E1000_SUCCESS;
+        s32 ret_val = 0;
         s32 i = 0, timeout = 200; /* FIXME: find real value to use here */
 
         while (i < timeout) {
@@ -187,7 +184,7 @@ void igb_release_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
 {
         u32 swfw_sync;
 
-        while (igb_get_hw_semaphore_i210(hw) != E1000_SUCCESS)
+        while (igb_get_hw_semaphore_i210(hw))
                 ; /* Empty */
 
         swfw_sync = rd32(E1000_SW_FW_SYNC);
@@ -210,7 +207,7 @@ void igb_release_swfw_sync_i210(struct e1000_hw *hw, u16 mask)
 static s32 igb_read_nvm_srrd_i210(struct e1000_hw *hw, u16 offset, u16 words,
                                   u16 *data)
 {
-        s32 status = E1000_SUCCESS;
+        s32 status = 0;
         u16 i, count;
 
         /* We cannot hold synchronization semaphores for too long,
@@ -220,7 +217,7 @@ static s32 igb_read_nvm_srrd_i210(struct e1000_hw *hw, u16 offset, u16 words,
         for (i = 0; i < words; i += E1000_EERD_EEWR_MAX_COUNT) {
                 count = (words - i) / E1000_EERD_EEWR_MAX_COUNT > 0 ?
                         E1000_EERD_EEWR_MAX_COUNT : (words - i);
-                if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
+                if (!(hw->nvm.ops.acquire(hw))) {
                         status = igb_read_nvm_eerd(hw, offset, count,
                                                      data + i);
                         hw->nvm.ops.release(hw);
@@ -228,7 +225,7 @@ static s32 igb_read_nvm_srrd_i210(struct e1000_hw *hw, u16 offset, u16 words,
                         status = E1000_ERR_SWFW_SYNC;
                 }
 
-                if (status != E1000_SUCCESS)
+                if (status)
                         break;
         }
 
@@ -253,7 +250,7 @@ static s32 igb_write_nvm_srwr(struct e1000_hw *hw, u16 offset, u16 words,
         struct e1000_nvm_info *nvm = &hw->nvm;
         u32 i, k, eewr = 0;
         u32 attempts = 100000;
-        s32 ret_val = E1000_SUCCESS;
+        s32 ret_val = 0;
 
         /* A check for invalid values:  offset too large, too many words,
          * too many words for the offset, and not enough words.
@@ -275,13 +272,13 @@ static s32 igb_write_nvm_srwr(struct e1000_hw *hw, u16 offset, u16 words,
                 for (k = 0; k < attempts; k++) {
                         if (E1000_NVM_RW_REG_DONE &
                             rd32(E1000_SRWR)) {
-                                ret_val = E1000_SUCCESS;
+                                ret_val = 0;
                                 break;
                         }
                         udelay(5);
         }
 
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         hw_dbg("Shadow RAM write EEWR timed out\n");
                         break;
                 }
@@ -310,7 +307,7 @@ out:
 static s32 igb_write_nvm_srwr_i210(struct e1000_hw *hw, u16 offset, u16 words,
                                    u16 *data)
 {
-        s32 status = E1000_SUCCESS;
+        s32 status = 0;
         u16 i, count;
 
         /* We cannot hold synchronization semaphores for too long,
@@ -320,7 +317,7 @@ static s32 igb_write_nvm_srwr_i210(struct e1000_hw *hw, u16 offset, u16 words,
         for (i = 0; i < words; i += E1000_EERD_EEWR_MAX_COUNT) {
                 count = (words - i) / E1000_EERD_EEWR_MAX_COUNT > 0 ?
                         E1000_EERD_EEWR_MAX_COUNT : (words - i);
-                if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
+                if (!(hw->nvm.ops.acquire(hw))) {
                         status = igb_write_nvm_srwr(hw, offset, count,
                                                       data + i);
                         hw->nvm.ops.release(hw);
@@ -328,7 +325,7 @@ static s32 igb_write_nvm_srwr_i210(struct e1000_hw *hw, u16 offset, u16 words,
                         status = E1000_ERR_SWFW_SYNC;
                 }
 
-                if (status != E1000_SUCCESS)
+                if (status)
                         break;
         }
 
@@ -367,12 +364,12 @@ static s32 igb_read_invm_word_i210(struct e1000_hw *hw, u8 address, u16 *data)
                                 *data = INVM_DWORD_TO_WORD_DATA(invm_dword);
                                 hw_dbg("Read INVM Word 0x%02x = %x\n",
                                           address, *data);
-                                status = E1000_SUCCESS;
+                                status = 0;
                                 break;
                         }
                 }
         }
-        if (status != E1000_SUCCESS)
+        if (status)
                 hw_dbg("Requested word 0x%02x not found in OTP\n", address);
         return status;
 }
@@ -388,7 +385,7 @@ static s32 igb_read_invm_word_i210(struct e1000_hw *hw, u8 address, u16 *data)
 static s32 igb_read_invm_i210(struct e1000_hw *hw, u16 offset,
                                 u16 words __always_unused, u16 *data)
 {
-        s32 ret_val = E1000_SUCCESS;
+        s32 ret_val = 0;
 
         /* Only the MAC addr is required to be present in the iNVM */
         switch (offset) {
@@ -398,43 +395,44 @@ static s32 igb_read_invm_i210(struct e1000_hw *hw, u16 offset,
                                                      &data[1]);
                 ret_val |= igb_read_invm_word_i210(hw, (u8)offset+2,
                                                      &data[2]);
-                if (ret_val != E1000_SUCCESS)
+                if (ret_val)
                         hw_dbg("MAC Addr not found in iNVM\n");
                 break;
         case NVM_INIT_CTRL_2:
                 ret_val = igb_read_invm_word_i210(hw, (u8)offset, data);
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         *data = NVM_INIT_CTRL_2_DEFAULT_I211;
-                        ret_val = E1000_SUCCESS;
+                        ret_val = 0;
                 }
                 break;
         case NVM_INIT_CTRL_4:
                 ret_val = igb_read_invm_word_i210(hw, (u8)offset, data);
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         *data = NVM_INIT_CTRL_4_DEFAULT_I211;
-                        ret_val = E1000_SUCCESS;
+                        ret_val = 0;
                 }
                 break;
         case NVM_LED_1_CFG:
                 ret_val = igb_read_invm_word_i210(hw, (u8)offset, data);
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         *data = NVM_LED_1_CFG_DEFAULT_I211;
-                        ret_val = E1000_SUCCESS;
+                        ret_val = 0;
                 }
                 break;
         case NVM_LED_0_2_CFG:
                 ret_val = igb_read_invm_word_i210(hw, (u8)offset, data);
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         *data = NVM_LED_0_2_CFG_DEFAULT_I211;
-                        ret_val = E1000_SUCCESS;
+                        ret_val = 0;
                 }
                 break;
         case NVM_ID_LED_SETTINGS:
                 ret_val = igb_read_invm_word_i210(hw, (u8)offset, data);
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         *data = ID_LED_RESERVED_FFFF;
-                        ret_val = E1000_SUCCESS;
+                        ret_val = 0;
                 }
+                break;
         case NVM_SUB_DEV_ID:
                 *data = hw->subsystem_device_id;
                 break;
@@ -488,14 +486,14 @@ s32 igb_read_invm_version(struct e1000_hw *hw,
                 /* Check if we have first version location used */
                 if ((i == 1) && ((*record & E1000_INVM_VER_FIELD_ONE) == 0)) {
                         version = 0;
-                        status = E1000_SUCCESS;
+                        status = 0;
                         break;
                 }
                 /* Check if we have second version location used */
                 else if ((i == 1) &&
                          ((*record & E1000_INVM_VER_FIELD_TWO) == 0)) {
                         version = (*record & E1000_INVM_VER_FIELD_ONE) >> 3;
-                        status = E1000_SUCCESS;
+                        status = 0;
                         break;
                 }
                 /* Check if we have odd version location
@@ -506,7 +504,7 @@ s32 igb_read_invm_version(struct e1000_hw *hw,
                          (i != 1))) {
                         version = (*next_record & E1000_INVM_VER_FIELD_TWO)
                                   >> 13;
-                        status = E1000_SUCCESS;
+                        status = 0;
                         break;
                 }
                 /* Check if we have even version location
@@ -515,12 +513,12 @@ s32 igb_read_invm_version(struct e1000_hw *hw,
                 else if (((*record & E1000_INVM_VER_FIELD_TWO) == 0) &&
                          ((*record & 0x3) == 0)) {
                         version = (*record & E1000_INVM_VER_FIELD_ONE) >> 3;
-                        status = E1000_SUCCESS;
+                        status = 0;
                         break;
                 }
         }
 
-        if (status == E1000_SUCCESS) {
+        if (!status) {
                 invm_ver->invm_major = (version & E1000_INVM_MAJOR_MASK)
                                         >> E1000_INVM_MAJOR_SHIFT;
                 invm_ver->invm_minor = version & E1000_INVM_MINOR_MASK;
@@ -533,7 +531,7 @@ s32 igb_read_invm_version(struct e1000_hw *hw,
                 /* Check if we have image type in first location used */
                 if ((i == 1) && ((*record & E1000_INVM_IMGTYPE_FIELD) == 0)) {
                         invm_ver->invm_img_type = 0;
-                        status = E1000_SUCCESS;
+                        status = 0;
                         break;
                 }
                 /* Check if we have image type in first location used */
@@ -542,7 +540,7 @@ s32 igb_read_invm_version(struct e1000_hw *hw,
                          ((((*record & 0x3) != 0) && (i != 1)))) {
                         invm_ver->invm_img_type =
                                 (*next_record & E1000_INVM_IMGTYPE_FIELD) >> 23;
-                        status = E1000_SUCCESS;
+                        status = 0;
                         break;
                 }
         }
@@ -558,10 +556,10 @@ s32 igb_read_invm_version(struct e1000_hw *hw,
  **/
 static s32 igb_validate_nvm_checksum_i210(struct e1000_hw *hw)
 {
-        s32 status = E1000_SUCCESS;
+        s32 status = 0;
         s32 (*read_op_ptr)(struct e1000_hw *, u16, u16, u16 *);
 
-        if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
+        if (!(hw->nvm.ops.acquire(hw))) {
 
                 /* Replace the read function with semaphore grabbing with
                  * the one that skips this for a while.
@@ -593,7 +591,7 @@ static s32 igb_validate_nvm_checksum_i210(struct e1000_hw *hw)
  **/
 static s32 igb_update_nvm_checksum_i210(struct e1000_hw *hw)
 {
-        s32 ret_val = E1000_SUCCESS;
+        s32 ret_val = 0;
         u16 checksum = 0;
         u16 i, nvm_data;
 
@@ -602,12 +600,12 @@ static s32 igb_update_nvm_checksum_i210(struct e1000_hw *hw)
          * EEPROM read fails
          */
         ret_val = igb_read_nvm_eerd(hw, 0, 1, &nvm_data);
-        if (ret_val != E1000_SUCCESS) {
+        if (ret_val) {
                 hw_dbg("EEPROM read failed\n");
                 goto out;
         }
 
-        if (hw->nvm.ops.acquire(hw) == E1000_SUCCESS) {
+        if (!(hw->nvm.ops.acquire(hw))) {
                 /* Do not use hw->nvm.ops.write, hw->nvm.ops.read
                  * because we do not want to take the synchronization
                  * semaphores twice here.
@@ -625,7 +623,7 @@ static s32 igb_update_nvm_checksum_i210(struct e1000_hw *hw)
                 checksum = (u16) NVM_SUM - checksum;
                 ret_val = igb_write_nvm_srwr(hw, NVM_CHECKSUM_REG, 1,
                                                 &checksum);
-                if (ret_val != E1000_SUCCESS) {
+                if (ret_val) {
                         hw->nvm.ops.release(hw);
                         hw_dbg("NVM Write Error while updating checksum.\n");
                         goto out;
@@ -654,7 +652,7 @@ static s32 igb_pool_flash_update_done_i210(struct e1000_hw *hw)
         for (i = 0; i < E1000_FLUDONE_ATTEMPTS; i++) {
                 reg = rd32(E1000_EECD);
                 if (reg & E1000_EECD_FLUDONE_I210) {
-                        ret_val = E1000_SUCCESS;
+                        ret_val = 0;
                         break;
                 }
                 udelay(5);
@@ -687,7 +685,7 @@ bool igb_get_flash_presence_i210(struct e1000_hw *hw)
  **/
 static s32 igb_update_flash_i210(struct e1000_hw *hw)
 {
-        s32 ret_val = E1000_SUCCESS;
+        s32 ret_val = 0;
         u32 flup;
 
         ret_val = igb_pool_flash_update_done_i210(hw);
@@ -700,7 +698,7 @@ static s32 igb_update_flash_i210(struct e1000_hw *hw)
         wr32(E1000_EECD, flup);
 
         ret_val = igb_pool_flash_update_done_i210(hw);
-        if (ret_val == E1000_SUCCESS)
+        if (ret_val)
                 hw_dbg("Flash update complete\n");
         else
                 hw_dbg("Flash update time out\n");
@@ -753,7 +751,7 @@ out:
 static s32 __igb_access_xmdio_reg(struct e1000_hw *hw, u16 address,
                                   u8 dev_addr, u16 *data, bool read)
 {
-        s32 ret_val = E1000_SUCCESS;
+        s32 ret_val = 0;
 
         ret_val = hw->phy.ops.write_reg(hw, E1000_MMDAC, dev_addr);
         if (ret_val)