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
  ...

108 files changed, 2197 insertions, 540 deletions

diff --git a/include/linux/ath9k_platform.h b/include/linux/ath9k_platform.h
index 8598f8eacb20..a495a959e8a7 100644
--- a/include/linux/ath9k_platform.h
+++ b/include/linux/ath9k_platform.h
@@ -36,6 +36,8 @@ struct ath9k_platform_data {
 
         int (*get_mac_revision)(void);
         int (*external_reset)(void);
+
+        bool use_eeprom;
 };
 
 #endif /* _LINUX_ATH9K_PLATFORM_H */
diff --git a/include/linux/can/core.h b/include/linux/can/core.h
index 78c6c52073ad..a0875001b13c 100644
--- a/include/linux/can/core.h
+++ b/include/linux/can/core.h
@@ -10,8 +10,8 @@
  *
  */
 
-#ifndef CAN_CORE_H
-#define CAN_CORE_H
+#ifndef _CAN_CORE_H
+#define _CAN_CORE_H
 
 #include <linux/can.h>
 #include <linux/skbuff.h>
@@ -58,4 +58,4 @@ extern void can_rx_unregister(struct net_device *dev, canid_t can_id,
 extern int can_send(struct sk_buff *skb, int loop);
 extern int can_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg);
 
-#endif /* CAN_CORE_H */
+#endif /* !_CAN_CORE_H */
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 3ce5e526525f..6992afc6ba7f 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -10,8 +10,8 @@
  *
  */
 
-#ifndef CAN_DEV_H
-#define CAN_DEV_H
+#ifndef _CAN_DEV_H
+#define _CAN_DEV_H
 
 #include <linux/can.h>
 #include <linux/can/netlink.h>
@@ -132,4 +132,4 @@ struct sk_buff *alloc_canfd_skb(struct net_device *dev,
 struct sk_buff *alloc_can_err_skb(struct net_device *dev,
                                   struct can_frame **cf);
 
-#endif /* CAN_DEV_H */
+#endif /* !_CAN_DEV_H */
diff --git a/include/linux/can/led.h b/include/linux/can/led.h
index 9c1167baf273..e0475c5cbb92 100644
--- a/include/linux/can/led.h
+++ b/include/linux/can/led.h
@@ -6,8 +6,8 @@
  * published by the Free Software Foundation.
  */
 
-#ifndef CAN_LED_H
-#define CAN_LED_H
+#ifndef _CAN_LED_H
+#define _CAN_LED_H
 
 #include <linux/if.h>
 #include <linux/leds.h>
@@ -48,4 +48,4 @@ static inline void can_led_notifier_exit(void)
 
 #endif
 
-#endif
+#endif /* !_CAN_LED_H */
diff --git a/include/linux/can/platform/cc770.h b/include/linux/can/platform/cc770.h
index 7702641f87ee..78b2d44f04cf 100644
--- a/include/linux/can/platform/cc770.h
+++ b/include/linux/can/platform/cc770.h
@@ -1,5 +1,5 @@
-#ifndef _CAN_PLATFORM_CC770_H_
-#define _CAN_PLATFORM_CC770_H_
+#ifndef _CAN_PLATFORM_CC770_H
+#define _CAN_PLATFORM_CC770_H
 
 /* CPU Interface Register (0x02) */
 #define CPUIF_CEN       0x01    /* Clock Out Enable */
@@ -30,4 +30,4 @@ struct cc770_platform_data {
         u8 bcr;         /* Bus Configuration Register */
 };
 
-#endif  /* !_CAN_PLATFORM_CC770_H_ */
+#endif  /* !_CAN_PLATFORM_CC770_H */
diff --git a/include/linux/can/platform/mcp251x.h b/include/linux/can/platform/mcp251x.h
index dc029dba7a03..d44fcae274ff 100644
--- a/include/linux/can/platform/mcp251x.h
+++ b/include/linux/can/platform/mcp251x.h
@@ -1,5 +1,5 @@
-#ifndef __CAN_PLATFORM_MCP251X_H__
-#define __CAN_PLATFORM_MCP251X_H__
+#ifndef _CAN_PLATFORM_MCP251X_H
+#define _CAN_PLATFORM_MCP251X_H
 
 /*
  *
@@ -18,4 +18,4 @@ struct mcp251x_platform_data {
         unsigned long oscillator_frequency;
 };
 
-#endif /* __CAN_PLATFORM_MCP251X_H__ */
+#endif /* !_CAN_PLATFORM_MCP251X_H */
diff --git a/include/linux/can/platform/rcar_can.h b/include/linux/can/platform/rcar_can.h
new file mode 100644
index 000000000000..0f4a2f3df504
--- /dev/null
+++ b/include/linux/can/platform/rcar_can.h
@@ -0,0 +1,17 @@
+#ifndef _CAN_PLATFORM_RCAR_CAN_H_
+#define _CAN_PLATFORM_RCAR_CAN_H_
+
+#include <linux/types.h>
+
+/* Clock Select Register settings */
+enum CLKR {
+        CLKR_CLKP1 = 0, /* Peripheral clock (clkp1) */
+        CLKR_CLKP2 = 1, /* Peripheral clock (clkp2) */
+        CLKR_CLKEXT = 3 /* Externally input clock */
+};
+
+struct rcar_can_platform_data {
+        enum CLKR clock_select; /* Clock source select */
+};
+
+#endif  /* !_CAN_PLATFORM_RCAR_CAN_H_ */
diff --git a/include/linux/can/platform/sja1000.h b/include/linux/can/platform/sja1000.h
index 96f8fcc78d78..93570b61ec6c 100644
--- a/include/linux/can/platform/sja1000.h
+++ b/include/linux/can/platform/sja1000.h
@@ -1,5 +1,5 @@
-#ifndef _CAN_PLATFORM_SJA1000_H_
-#define _CAN_PLATFORM_SJA1000_H_
+#ifndef _CAN_PLATFORM_SJA1000_H
+#define _CAN_PLATFORM_SJA1000_H
 
 /* clock divider register */
 #define CDR_CLKOUT_MASK 0x07
@@ -32,4 +32,4 @@ struct sja1000_platform_data {
         u8 cdr;         /* clock divider register */
 };
 
-#endif  /* !_CAN_PLATFORM_SJA1000_H_ */
+#endif  /* !_CAN_PLATFORM_SJA1000_H */
diff --git a/include/linux/can/platform/ti_hecc.h b/include/linux/can/platform/ti_hecc.h
index af17cb3f7a84..a52f47ca6c8a 100644
--- a/include/linux/can/platform/ti_hecc.h
+++ b/include/linux/can/platform/ti_hecc.h
@@ -1,5 +1,5 @@
-#ifndef __CAN_PLATFORM_TI_HECC_H__
-#define __CAN_PLATFORM_TI_HECC_H__
+#ifndef _CAN_PLATFORM_TI_HECC_H
+#define _CAN_PLATFORM_TI_HECC_H
 
 /*
  * TI HECC (High End CAN Controller) driver platform header
@@ -41,4 +41,4 @@ struct ti_hecc_platform_data {
         u32 version;
         void (*transceiver_switch) (int);
 };
-#endif
+#endif /* !_CAN_PLATFORM_TI_HECC_H */
diff --git a/include/linux/can/skb.h b/include/linux/can/skb.h
index f9bbbb472663..cc00d15c6107 100644
--- a/include/linux/can/skb.h
+++ b/include/linux/can/skb.h
@@ -7,8 +7,8 @@
  *
  */
 
-#ifndef CAN_SKB_H
-#define CAN_SKB_H
+#ifndef _CAN_SKB_H
+#define _CAN_SKB_H
 
 #include <linux/types.h>
 #include <linux/skbuff.h>
@@ -80,4 +80,4 @@ static inline struct sk_buff *can_create_echo_skb(struct sk_buff *skb)
         return skb;
 }
 
-#endif /* CAN_SKB_H */
+#endif /* !_CAN_SKB_H */
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index 3557ea7b2049..2997af6d2ccd 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -142,6 +142,13 @@ static inline unsigned int cpumask_any_but(const struct cpumask *mask,
         return 1;
 }
 
+static inline int cpumask_set_cpu_local_first(int i, int numa_node, cpumask_t *dstp)
+{
+        set_bit(0, cpumask_bits(dstp));
+
+        return 0;
+}
+
 #define for_each_cpu(cpu, mask)                 \
         for ((cpu) = 0; (cpu) < 1; (cpu)++, (void)mask)
 #define for_each_cpu_not(cpu, mask)             \
@@ -192,6 +199,7 @@ static inline unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
 
 int cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
 int cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
+int cpumask_set_cpu_local_first(int i, int numa_node, cpumask_t *dstp);
 
 /**
  * for_each_cpu - iterate over every cpu in a mask
diff --git a/include/linux/crc7.h b/include/linux/crc7.h
index 1786e772d5c6..d590765106f3 100644
--- a/include/linux/crc7.h
+++ b/include/linux/crc7.h
@@ -2,13 +2,13 @@
 #define _LINUX_CRC7_H
 #include <linux/types.h>
 
-extern const u8 crc7_syndrome_table[256];
+extern const u8 crc7_be_syndrome_table[256];
 
-static inline u8 crc7_byte(u8 crc, u8 data)
+static inline u8 crc7_be_byte(u8 crc, u8 data)
 {
-        return crc7_syndrome_table[(crc << 1) ^ data];
+        return crc7_be_syndrome_table[crc ^ data];
 }
 
-extern u8 crc7(u8 crc, const u8 *buffer, size_t len);
+extern u8 crc7_be(u8 crc, const u8 *buffer, size_t len);
 
 #endif
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 0a114d05f68d..e658229fee39 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -154,13 +154,20 @@ static inline u32 ethtool_rxfh_indir_default(u32 index, u32 n_rx_rings)
  * @reset: Reset (part of) the device, as specified by a bitmask of
  *      flags from &enum ethtool_reset_flags.  Returns a negative
  *      error code or zero.
+ * @get_rxfh_key_size: Get the size of the RX flow hash key.
+ *      Returns zero if not supported for this specific device.
  * @get_rxfh_indir_size: Get the size of the RX flow hash indirection table.
  *      Returns zero if not supported for this specific device.
- * @get_rxfh_indir: Get the contents of the RX flow hash indirection table.
- *      Will not be called if @get_rxfh_indir_size returns zero.
+ * @get_rxfh: Get the contents of the RX flow hash indirection table and hash
+ *      key.
+ *      Will only be called if one or both of @get_rxfh_indir_size and
+ *      @get_rxfh_key_size are implemented and return non-zero.
  *      Returns a negative error code or zero.
- * @set_rxfh_indir: Set the contents of the RX flow hash indirection table.
- *      Will not be called if @get_rxfh_indir_size returns zero.
+ * @set_rxfh: Set the contents of the RX flow hash indirection table and/or
+ *      hash key.  In case only the indirection table or hash key is to be
+ *      changed, the other argument will be %NULL.
+ *      Will only be called if one or both of @get_rxfh_indir_size and
+ *      @get_rxfh_key_size are implemented and return non-zero.
  *      Returns a negative error code or zero.
  * @get_channels: Get number of channels.
  * @set_channels: Set number of channels.  Returns a negative error code or
@@ -232,9 +239,11 @@ struct ethtool_ops {
         int     (*set_rxnfc)(struct net_device *, struct ethtool_rxnfc *);
         int     (*flash_device)(struct net_device *, struct ethtool_flash *);
         int     (*reset)(struct net_device *, u32 *);
+        u32     (*get_rxfh_key_size)(struct net_device *);
         u32     (*get_rxfh_indir_size)(struct net_device *);
-        int     (*get_rxfh_indir)(struct net_device *, u32 *);
-        int     (*set_rxfh_indir)(struct net_device *, const u32 *);
+        int     (*get_rxfh)(struct net_device *, u32 *indir, u8 *key);
+        int     (*set_rxfh)(struct net_device *, const u32 *indir,
+                            const u8 *key);
         void    (*get_channels)(struct net_device *, struct ethtool_channels *);
         int     (*set_channels)(struct net_device *, struct ethtool_channels *);
         int     (*get_dump_flag)(struct net_device *, struct ethtool_dump *);
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 024fd03e5d18..a7e3c48d73a7 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -37,21 +37,270 @@
 #define BPF_CALL        0x80    /* function call */
 #define BPF_EXIT        0x90    /* function return */
 
+/* Register numbers */
+enum {
+        BPF_REG_0 = 0,
+        BPF_REG_1,
+        BPF_REG_2,
+        BPF_REG_3,
+        BPF_REG_4,
+        BPF_REG_5,
+        BPF_REG_6,
+        BPF_REG_7,
+        BPF_REG_8,
+        BPF_REG_9,
+        BPF_REG_10,
+        __MAX_BPF_REG,
+};
+
 /* BPF has 10 general purpose 64-bit registers and stack frame. */
-#define MAX_BPF_REG     11
+#define MAX_BPF_REG     __MAX_BPF_REG
+
+/* ArgX, context and stack frame pointer register positions. Note,
+ * Arg1, Arg2, Arg3, etc are used as argument mappings of function
+ * calls in BPF_CALL instruction.
+ */
+#define BPF_REG_ARG1    BPF_REG_1
+#define BPF_REG_ARG2    BPF_REG_2
+#define BPF_REG_ARG3    BPF_REG_3
+#define BPF_REG_ARG4    BPF_REG_4
+#define BPF_REG_ARG5    BPF_REG_5
+#define BPF_REG_CTX     BPF_REG_6
+#define BPF_REG_FP      BPF_REG_10
+
+/* Additional register mappings for converted user programs. */
+#define BPF_REG_A       BPF_REG_0
+#define BPF_REG_X       BPF_REG_7
+#define BPF_REG_TMP     BPF_REG_8
 
 /* BPF program can access up to 512 bytes of stack space. */
 #define MAX_BPF_STACK   512
 
-/* Arg1, context and stack frame pointer register positions. */
-#define ARG1_REG        1
-#define CTX_REG         6
-#define FP_REG          10
+/* Helper macros for filter block array initializers. */
+
+/* ALU ops on registers, bpf_add|sub|...: dst_reg += src_reg */
+
+#define BPF_ALU64_REG(OP, DST, SRC)                             \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU64 | BPF_OP(OP) | BPF_X,        \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = 0 })
+
+#define BPF_ALU32_REG(OP, DST, SRC)                             \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU | BPF_OP(OP) | BPF_X,          \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = 0 })
+
+/* ALU ops on immediates, bpf_add|sub|...: dst_reg += imm32 */
+
+#define BPF_ALU64_IMM(OP, DST, IMM)                             \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU64 | BPF_OP(OP) | BPF_K,        \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+#define BPF_ALU32_IMM(OP, DST, IMM)                             \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU | BPF_OP(OP) | BPF_K,          \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+/* Endianess conversion, cpu_to_{l,b}e(), {l,b}e_to_cpu() */
+
+#define BPF_ENDIAN(TYPE, DST, LEN)                              \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU | BPF_END | BPF_SRC(TYPE),     \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = LEN })
+
+/* Short form of mov, dst_reg = src_reg */
+
+#define BPF_MOV64_REG(DST, SRC)                                 \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU64 | BPF_MOV | BPF_X,           \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = 0 })
+
+#define BPF_MOV32_REG(DST, SRC)                                 \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU | BPF_MOV | BPF_X,             \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = 0 })
+
+/* Short form of mov, dst_reg = imm32 */
+
+#define BPF_MOV64_IMM(DST, IMM)                                 \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU64 | BPF_MOV | BPF_K,           \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+#define BPF_MOV32_IMM(DST, IMM)                                 \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU | BPF_MOV | BPF_K,             \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+/* Short form of mov based on type, BPF_X: dst_reg = src_reg, BPF_K: dst_reg = imm32 */
+
+#define BPF_MOV64_RAW(TYPE, DST, SRC, IMM)                      \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU64 | BPF_MOV | BPF_SRC(TYPE),   \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+#define BPF_MOV32_RAW(TYPE, DST, SRC, IMM)                      \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ALU | BPF_MOV | BPF_SRC(TYPE),     \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+/* Direct packet access, R0 = *(uint *) (skb->data + imm32) */
+
+#define BPF_LD_ABS(SIZE, IMM)                                   \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_LD | BPF_SIZE(SIZE) | BPF_ABS,     \
+                .dst_reg = 0,                                   \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+/* Indirect packet access, R0 = *(uint *) (skb->data + src_reg + imm32) */
+
+#define BPF_LD_IND(SIZE, SRC, IMM)                              \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_LD | BPF_SIZE(SIZE) | BPF_IND,     \
+                .dst_reg = 0,                                   \
+                .src_reg = SRC,                                 \
+                .off   = 0,                                     \
+                .imm   = IMM })
+
+/* Memory load, dst_reg = *(uint *) (src_reg + off16) */
+
+#define BPF_LDX_MEM(SIZE, DST, SRC, OFF)                        \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_LDX | BPF_SIZE(SIZE) | BPF_MEM,    \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = 0 })
+
+/* Memory store, *(uint *) (dst_reg + off16) = src_reg */
+
+#define BPF_STX_MEM(SIZE, DST, SRC, OFF)                        \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_STX | BPF_SIZE(SIZE) | BPF_MEM,    \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = 0 })
+
+/* Memory store, *(uint *) (dst_reg + off16) = imm32 */
+
+#define BPF_ST_MEM(SIZE, DST, OFF, IMM)                         \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_ST | BPF_SIZE(SIZE) | BPF_MEM,     \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = OFF,                                   \
+                .imm   = IMM })
+
+/* Conditional jumps against registers, if (dst_reg 'op' src_reg) goto pc + off16 */
+
+#define BPF_JMP_REG(OP, DST, SRC, OFF)                          \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_JMP | BPF_OP(OP) | BPF_X,          \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = 0 })
+
+/* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */
+
+#define BPF_JMP_IMM(OP, DST, IMM, OFF)                          \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_JMP | BPF_OP(OP) | BPF_K,          \
+                .dst_reg = DST,                                 \
+                .src_reg = 0,                                   \
+                .off   = OFF,                                   \
+                .imm   = IMM })
+
+/* Function call */
+
+#define BPF_EMIT_CALL(FUNC)                                     \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_JMP | BPF_CALL,                    \
+                .dst_reg = 0,                                   \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = ((FUNC) - __bpf_call_base) })
+
+/* Raw code statement block */
+
+#define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)                  \
+        ((struct sock_filter_int) {                             \
+                .code  = CODE,                                  \
+                .dst_reg = DST,                                 \
+                .src_reg = SRC,                                 \
+                .off   = OFF,                                   \
+                .imm   = IMM })
+
+/* Program exit */
+
+#define BPF_EXIT_INSN()                                         \
+        ((struct sock_filter_int) {                             \
+                .code  = BPF_JMP | BPF_EXIT,                    \
+                .dst_reg = 0,                                   \
+                .src_reg = 0,                                   \
+                .off   = 0,                                     \
+                .imm   = 0 })
+
+#define bytes_to_bpf_size(bytes)                                \
+({                                                              \
+        int bpf_size = -EINVAL;                                 \
+                                                                \
+        if (bytes == sizeof(u8))                                \
+                bpf_size = BPF_B;                               \
+        else if (bytes == sizeof(u16))                          \
+                bpf_size = BPF_H;                               \
+        else if (bytes == sizeof(u32))                          \
+                bpf_size = BPF_W;                               \
+        else if (bytes == sizeof(u64))                          \
+                bpf_size = BPF_DW;                              \
+                                                                \
+        bpf_size;                                               \
+})
+
+/* Macro to invoke filter function. */
+#define SK_RUN_FILTER(filter, ctx)  (*filter->bpf_func)(ctx, filter->insnsi)
 
 struct sock_filter_int {
         __u8    code;           /* opcode */
-        __u8    a_reg:4;        /* dest register */
-        __u8    x_reg:4;        /* source register */
+        __u8    dst_reg:4;      /* dest register */
+        __u8    src_reg:4;      /* source register */
         __s16   off;            /* signed offset */
         __s32   imm;            /* signed immediate constant */
 };
@@ -97,21 +346,16 @@ static inline unsigned int sk_filter_size(unsigned int proglen)
 #define sk_filter_proglen(fprog)                        \
                 (fprog->len * sizeof(fprog->filter[0]))
 
-#define SK_RUN_FILTER(filter, ctx)                      \
-                (*filter->bpf_func)(ctx, filter->insnsi)
-
 int sk_filter(struct sock *sk, struct sk_buff *skb);
 
-u32 sk_run_filter_int_seccomp(const struct seccomp_data *ctx,
-                              const struct sock_filter_int *insni);
-u32 sk_run_filter_int_skb(const struct sk_buff *ctx,
-                          const struct sock_filter_int *insni);
+void sk_filter_select_runtime(struct sk_filter *fp);
+void sk_filter_free(struct sk_filter *fp);
 
 int sk_convert_filter(struct sock_filter *prog, int len,
                       struct sock_filter_int *new_prog, int *new_len);
 
 int sk_unattached_filter_create(struct sk_filter **pfp,
-                                struct sock_fprog *fprog);
+                                struct sock_fprog_kern *fprog);
 void sk_unattached_filter_destroy(struct sk_filter *fp);
 
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
@@ -120,11 +364,48 @@ int sk_detach_filter(struct sock *sk);
 int sk_chk_filter(struct sock_filter *filter, unsigned int flen);
 int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
                   unsigned int len);
-void sk_decode_filter(struct sock_filter *filt, struct sock_filter *to);
 
 void sk_filter_charge(struct sock *sk, struct sk_filter *fp);
 void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp);
 
+u64 __bpf_call_base(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
+void bpf_int_jit_compile(struct sk_filter *fp);
+
+#define BPF_ANC         BIT(15)
+
+static inline u16 bpf_anc_helper(const struct sock_filter *ftest)
+{
+        BUG_ON(ftest->code & BPF_ANC);
+
+        switch (ftest->code) {
+        case BPF_LD | BPF_W | BPF_ABS:
+        case BPF_LD | BPF_H | BPF_ABS:
+        case BPF_LD | BPF_B | BPF_ABS:
+#define BPF_ANCILLARY(CODE)     case SKF_AD_OFF + SKF_AD_##CODE:        \
+                                return BPF_ANC | SKF_AD_##CODE
+                switch (ftest->k) {
+                BPF_ANCILLARY(PROTOCOL);
+                BPF_ANCILLARY(PKTTYPE);
+                BPF_ANCILLARY(IFINDEX);
+                BPF_ANCILLARY(NLATTR);
+                BPF_ANCILLARY(NLATTR_NEST);
+                BPF_ANCILLARY(MARK);
+                BPF_ANCILLARY(QUEUE);
+                BPF_ANCILLARY(HATYPE);
+                BPF_ANCILLARY(RXHASH);
+                BPF_ANCILLARY(CPU);
+                BPF_ANCILLARY(ALU_XOR_X);
+                BPF_ANCILLARY(VLAN_TAG);
+                BPF_ANCILLARY(VLAN_TAG_PRESENT);
+                BPF_ANCILLARY(PAY_OFFSET);
+                BPF_ANCILLARY(RANDOM);
+                }
+                /* Fallthrough. */
+        default:
+                return ftest->code;
+        }
+}
+
 #ifdef CONFIG_BPF_JIT
 #include <stdarg.h>
 #include <linux/linkage.h>
@@ -144,85 +425,20 @@ static inline void bpf_jit_dump(unsigned int flen, unsigned int proglen,
 }
 #else
 #include <linux/slab.h>
+
 static inline void bpf_jit_compile(struct sk_filter *fp)
 {
 }
+
 static inline void bpf_jit_free(struct sk_filter *fp)
 {
         kfree(fp);
 }
-#endif
+#endif /* CONFIG_BPF_JIT */
 
 static inline int bpf_tell_extensions(void)
 {
         return SKF_AD_MAX;
 }
 
-enum {
-        BPF_S_RET_K = 1,
-        BPF_S_RET_A,
-        BPF_S_ALU_ADD_K,
-        BPF_S_ALU_ADD_X,
-        BPF_S_ALU_SUB_K,
-        BPF_S_ALU_SUB_X,
-        BPF_S_ALU_MUL_K,
-        BPF_S_ALU_MUL_X,
-        BPF_S_ALU_DIV_X,
-        BPF_S_ALU_MOD_K,
-        BPF_S_ALU_MOD_X,
-        BPF_S_ALU_AND_K,
-        BPF_S_ALU_AND_X,
-        BPF_S_ALU_OR_K,
-        BPF_S_ALU_OR_X,
-        BPF_S_ALU_XOR_K,
-        BPF_S_ALU_XOR_X,
-        BPF_S_ALU_LSH_K,
-        BPF_S_ALU_LSH_X,
-        BPF_S_ALU_RSH_K,
-        BPF_S_ALU_RSH_X,
-        BPF_S_ALU_NEG,
-        BPF_S_LD_W_ABS,
-        BPF_S_LD_H_ABS,
-        BPF_S_LD_B_ABS,
-        BPF_S_LD_W_LEN,
-        BPF_S_LD_W_IND,
-        BPF_S_LD_H_IND,
-        BPF_S_LD_B_IND,
-        BPF_S_LD_IMM,
-        BPF_S_LDX_W_LEN,
-        BPF_S_LDX_B_MSH,
-        BPF_S_LDX_IMM,
-        BPF_S_MISC_TAX,
-        BPF_S_MISC_TXA,
-        BPF_S_ALU_DIV_K,
-        BPF_S_LD_MEM,
-        BPF_S_LDX_MEM,
-        BPF_S_ST,
-        BPF_S_STX,
-        BPF_S_JMP_JA,
-        BPF_S_JMP_JEQ_K,
-        BPF_S_JMP_JEQ_X,
-        BPF_S_JMP_JGE_K,
-        BPF_S_JMP_JGE_X,
-        BPF_S_JMP_JGT_K,
-        BPF_S_JMP_JGT_X,
-        BPF_S_JMP_JSET_K,
-        BPF_S_JMP_JSET_X,
-        /* Ancillary data */
-        BPF_S_ANC_PROTOCOL,
-        BPF_S_ANC_PKTTYPE,
-        BPF_S_ANC_IFINDEX,
-        BPF_S_ANC_NLATTR,
-        BPF_S_ANC_NLATTR_NEST,
-        BPF_S_ANC_MARK,
-        BPF_S_ANC_QUEUE,
-        BPF_S_ANC_HATYPE,
-        BPF_S_ANC_RXHASH,
-        BPF_S_ANC_CPU,
-        BPF_S_ANC_ALU_XOR_X,
-        BPF_S_ANC_VLAN_TAG,
-        BPF_S_ANC_VLAN_TAG_PRESENT,
-        BPF_S_ANC_PAY_OFFSET,
-};
-
 #endif /* __LINUX_FILTER_H__ */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index f194ccb8539c..6bff13f74050 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -1711,6 +1711,7 @@ enum ieee80211_eid {
         WLAN_EID_RRM_ENABLED_CAPABILITIES = 70,
         WLAN_EID_MULTIPLE_BSSID = 71,
         WLAN_EID_BSS_COEX_2040 = 72,
+        WLAN_EID_BSS_INTOLERANT_CHL_REPORT = 73,
         WLAN_EID_OVERLAP_BSS_SCAN_PARAM = 74,
         WLAN_EID_RIC_DESCRIPTOR = 75,
         WLAN_EID_MMIE = 76,
diff --git a/include/linux/if_bridge.h b/include/linux/if_bridge.h
index 1085ffeef956..fd22789d7b2e 100644
--- a/include/linux/if_bridge.h
+++ b/include/linux/if_bridge.h
@@ -16,9 +16,28 @@
 #include <linux/netdevice.h>
 #include <uapi/linux/if_bridge.h>
 
+struct br_ip {
+        union {
+                __be32  ip4;
+#if IS_ENABLED(CONFIG_IPV6)
+                struct in6_addr ip6;
+#endif
+        } u;
+        __be16          proto;
+        __u16           vid;
+};
+
+struct br_ip_list {
+        struct list_head list;
+        struct br_ip addr;
+};
+
 extern void brioctl_set(int (*ioctl_hook)(struct net *, unsigned int, void __user *));
 
 typedef int br_should_route_hook_t(struct sk_buff *skb);
 extern br_should_route_hook_t __rcu *br_should_route_hook;
+int br_multicast_list_adjacent(struct net_device *dev,
+                               struct list_head *br_ip_list);
+bool br_multicast_has_querier_adjacent(struct net_device *dev, int proto);
 
 #endif
diff --git a/include/linux/if_link.h b/include/linux/if_link.h
index a86784dec3d3..119130e9298b 100644
--- a/include/linux/if_link.h
+++ b/include/linux/if_link.h
@@ -10,8 +10,9 @@ struct ifla_vf_info {
         __u8 mac[32];
         __u32 vlan;
         __u32 qos;
-        __u32 tx_rate;
         __u32 spoofchk;
         __u32 linkstate;
+        __u32 min_tx_rate;
+        __u32 max_tx_rate;
 };
 #endif /* _LINUX_IF_LINK_H */
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index a9a53b12397b..6b2c7cf352a5 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -57,6 +57,9 @@ struct macvlan_dev {
         netdev_features_t       tap_features;
         int                     minor;
         int                     nest_level;
+#ifdef CONFIG_NET_POLL_CONTROLLER
+        struct netpoll          *netpoll;
+#endif
 };
 
 static inline void macvlan_count_rx(const struct macvlan_dev *vlan,
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index b2acc4a1b13c..4967916fe4ac 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -106,7 +106,7 @@ struct vlan_pcpu_stats {
 
 #if defined(CONFIG_VLAN_8021Q) || defined(CONFIG_VLAN_8021Q_MODULE)
 
-extern struct net_device *__vlan_find_dev_deep(struct net_device *real_dev,
+extern struct net_device *__vlan_find_dev_deep_rcu(struct net_device *real_dev,
                                                __be16 vlan_proto, u16 vlan_id);
 extern struct net_device *vlan_dev_real_dev(const struct net_device *dev);
 extern u16 vlan_dev_vlan_id(const struct net_device *dev);
@@ -206,7 +206,7 @@ static inline int vlan_get_encap_level(struct net_device *dev)
 }
 #else
 static inline struct net_device *
-__vlan_find_dev_deep(struct net_device *real_dev,
+__vlan_find_dev_deep_rcu(struct net_device *real_dev,
                      __be16 vlan_proto, u16 vlan_id)
 {
         return NULL;
diff --git a/include/linux/isdn/capiutil.h b/include/linux/isdn/capiutil.h
index 5a52f2c94f3f..44bd6046e6e2 100644
--- a/include/linux/isdn/capiutil.h
+++ b/include/linux/isdn/capiutil.h
@@ -164,11 +164,6 @@ unsigned capi_cmsg_header(_cmsg * cmsg, __u16 _ApplId,
                           __u8 _Command, __u8 _Subcommand,
                           __u16 _Messagenumber, __u32 _Controller);
 
-/*
- * capi_info2str generated a readable string for Capi2.0 reasons.
- */
-char *capi_info2str(__u16 reason);
-
 /*-----------------------------------------------------------------------*/
 
 /*
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index 31c0cd1c941a..de9e46e6bcc9 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -304,6 +304,30 @@ static inline int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
         return 0;
 }
 
+/**
+ * ktime_after - Compare if a ktime_t value is bigger than another one.
+ * @cmp1:       comparable1
+ * @cmp2:       comparable2
+ *
+ * Return: true if cmp1 happened after cmp2.
+ */
+static inline bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)
+{
+        return ktime_compare(cmp1, cmp2) > 0;
+}
+
+/**
+ * ktime_before - Compare if a ktime_t value is smaller than another one.
+ * @cmp1:       comparable1
+ * @cmp2:       comparable2
+ *
+ * Return: true if cmp1 happened before cmp2.
+ */
+static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
+{
+        return ktime_compare(cmp1, cmp2) < 0;
+}
+
 static inline s64 ktime_to_us(const ktime_t kt)
 {
         struct timeval tv = ktime_to_timeval(kt);
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 3447bead9620..b12f4bbd064c 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -450,7 +450,6 @@ struct mlx4_caps {
         int                     reserved_qps_base[MLX4_NUM_QP_REGION];
         int                     log_num_macs;
         int                     log_num_vlans;
-        int                     log_num_prios;
         enum mlx4_port_type     port_type[MLX4_MAX_PORTS + 1];
         u8                      supported_type[MLX4_MAX_PORTS + 1];
         u8                      suggested_type[MLX4_MAX_PORTS + 1];
@@ -578,6 +577,9 @@ struct mlx4_cq {
 
         u32                     cons_index;
 
+        u16                     irq;
+        bool                    irq_affinity_change;
+
         __be32                 *set_ci_db;
         __be32                 *arm_db;
         int                     arm_sn;
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index c26d0ec2ef3a..e5a589435e2b 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -42,9 +42,11 @@ enum {
         NETIF_F_TSO6_BIT,               /* ... TCPv6 segmentation */
         NETIF_F_FSO_BIT,                /* ... FCoE segmentation */
         NETIF_F_GSO_GRE_BIT,            /* ... GRE with TSO */
+        NETIF_F_GSO_GRE_CSUM_BIT,       /* ... GRE with csum with TSO */
         NETIF_F_GSO_IPIP_BIT,           /* ... IPIP tunnel with TSO */
         NETIF_F_GSO_SIT_BIT,            /* ... SIT tunnel with TSO */
         NETIF_F_GSO_UDP_TUNNEL_BIT,     /* ... UDP TUNNEL with TSO */
+        NETIF_F_GSO_UDP_TUNNEL_CSUM_BIT,/* ... UDP TUNNEL with TSO & CSUM */
         NETIF_F_GSO_MPLS_BIT,           /* ... MPLS segmentation */
         /**/NETIF_F_GSO_LAST =          /* last bit, see GSO_MASK */
                 NETIF_F_GSO_MPLS_BIT,
@@ -111,6 +113,7 @@ enum {
 #define NETIF_F_RXFCS           __NETIF_F(RXFCS)
 #define NETIF_F_RXALL           __NETIF_F(RXALL)
 #define NETIF_F_GSO_GRE         __NETIF_F(GSO_GRE)
+#define NETIF_F_GSO_GRE_CSUM    __NETIF_F(GSO_GRE_CSUM)
 #define NETIF_F_GSO_IPIP        __NETIF_F(GSO_IPIP)
 #define NETIF_F_GSO_SIT         __NETIF_F(GSO_SIT)
 #define NETIF_F_GSO_UDP_TUNNEL  __NETIF_F(GSO_UDP_TUNNEL)
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 6c1ae9fd9505..abe3de1db932 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -56,9 +56,6 @@ struct device;
 struct phy_device;
 /* 802.11 specific */
 struct wireless_dev;
-                                        /* source back-compat hooks */
-#define SET_ETHTOOL_OPS(netdev,ops) \
-        ( (netdev)->ethtool_ops = (ops) )
 
 void netdev_set_default_ethtool_ops(struct net_device *dev,
                                     const struct ethtool_ops *ops);
@@ -853,7 +850,8 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      SR-IOV management functions.
  * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
  * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
- * int (*ndo_set_vf_tx_rate)(struct net_device *dev, int vf, int rate);
+ * int (*ndo_set_vf_rate)(struct net_device *dev, int vf, int min_tx_rate,
+ *                        int max_tx_rate);
  * int (*ndo_set_vf_spoofchk)(struct net_device *dev, int vf, bool setting);
  * int (*ndo_get_vf_config)(struct net_device *dev,
  *                          int vf, struct ifla_vf_info *ivf);
@@ -1047,8 +1045,9 @@ struct net_device_ops {
                                                   int queue, u8 *mac);
         int                     (*ndo_set_vf_vlan)(struct net_device *dev,
                                                    int queue, u16 vlan, u8 qos);
-        int                     (*ndo_set_vf_tx_rate)(struct net_device *dev,
-                                                      int vf, int rate);
+        int                     (*ndo_set_vf_rate)(struct net_device *dev,
+                                                   int vf, int min_tx_rate,
+                                                   int max_tx_rate);
         int                     (*ndo_set_vf_spoofchk)(struct net_device *dev,
                                                        int vf, bool setting);
         int                     (*ndo_get_vf_config)(struct net_device *dev,
@@ -2634,6 +2633,7 @@ int dev_get_phys_port_id(struct net_device *dev,
                          struct netdev_phys_port_id *ppid);
 int dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
                         struct netdev_queue *txq);
+int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
 bool is_skb_forwardable(struct net_device *dev, struct sk_buff *skb);
 
@@ -3003,6 +3003,15 @@ int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
                    struct netdev_hw_addr_list *from_list, int addr_len);
 void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
                       struct netdev_hw_addr_list *from_list, int addr_len);
+int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
+                       struct net_device *dev,
+                       int (*sync)(struct net_device *, const unsigned char *),
+                       int (*unsync)(struct net_device *,
+                                     const unsigned char *));
+void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
+                          struct net_device *dev,
+                          int (*unsync)(struct net_device *,
+                                        const unsigned char *));
 void __hw_addr_init(struct netdev_hw_addr_list *list);
 
 /* Functions used for device addresses handling */
@@ -3023,6 +3032,38 @@ void dev_uc_unsync(struct net_device *to, struct net_device *from);
 void dev_uc_flush(struct net_device *dev);
 void dev_uc_init(struct net_device *dev);
 
+/**
+ *  __dev_uc_sync - Synchonize device's unicast list
+ *  @dev:  device to sync
+ *  @sync: function to call if address should be added
+ *  @unsync: function to call if address should be removed
+ *
+ *  Add newly added addresses to the interface, and release
+ *  addresses that have been deleted.
+ **/
+static inline int __dev_uc_sync(struct net_device *dev,
+                                int (*sync)(struct net_device *,
+                                            const unsigned char *),
+                                int (*unsync)(struct net_device *,
+                                              const unsigned char *))
+{
+        return __hw_addr_sync_dev(&dev->uc, dev, sync, unsync);
+}
+
+/**
+ *  __dev_uc_unsync - Remove synchonized addresses from device
+ *  @dev:  device to sync
+ *  @unsync: function to call if address should be removed
+ *
+ *  Remove all addresses that were added to the device by dev_uc_sync().
+ **/
+static inline void __dev_uc_unsync(struct net_device *dev,
+                                   int (*unsync)(struct net_device *,
+                                                 const unsigned char *))
+{
+        __hw_addr_unsync_dev(&dev->uc, dev, unsync);
+}
+
 /* Functions used for multicast addresses handling */
 int dev_mc_add(struct net_device *dev, const unsigned char *addr);
 int dev_mc_add_global(struct net_device *dev, const unsigned char *addr);
@@ -3035,6 +3076,38 @@ void dev_mc_unsync(struct net_device *to, struct net_device *from);
 void dev_mc_flush(struct net_device *dev);
 void dev_mc_init(struct net_device *dev);
 
+/**
+ *  __dev_mc_sync - Synchonize device's multicast list
+ *  @dev:  device to sync
+ *  @sync: function to call if address should be added
+ *  @unsync: function to call if address should be removed
+ *
+ *  Add newly added addresses to the interface, and release
+ *  addresses that have been deleted.
+ **/
+static inline int __dev_mc_sync(struct net_device *dev,
+                                int (*sync)(struct net_device *,
+                                            const unsigned char *),
+                                int (*unsync)(struct net_device *,
+                                              const unsigned char *))
+{
+        return __hw_addr_sync_dev(&dev->mc, dev, sync, unsync);
+}
+
+/**
+ *  __dev_mc_unsync - Remove synchonized addresses from device
+ *  @dev:  device to sync
+ *  @unsync: function to call if address should be removed
+ *
+ *  Remove all addresses that were added to the device by dev_mc_sync().
+ **/
+static inline void __dev_mc_unsync(struct net_device *dev,
+                                   int (*unsync)(struct net_device *,
+                                                 const unsigned char *))
+{
+        __hw_addr_unsync_dev(&dev->mc, dev, unsync);
+}
+
 /* Functions used for secondary unicast and multicast support */
 void dev_set_rx_mode(struct net_device *dev);
 void __dev_set_rx_mode(struct net_device *dev);
@@ -3180,6 +3253,20 @@ const char *netdev_drivername(const struct net_device *dev);
 
 void linkwatch_run_queue(void);
 
+static inline netdev_features_t netdev_intersect_features(netdev_features_t f1,
+                                                          netdev_features_t f2)
+{
+        if (f1 & NETIF_F_GEN_CSUM)
+                f1 |= (NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
+        if (f2 & NETIF_F_GEN_CSUM)
+                f2 |= (NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
+        f1 &= f2;
+        if (f1 & NETIF_F_GEN_CSUM)
+                f1 &= ~(NETIF_F_ALL_CSUM & ~NETIF_F_GEN_CSUM);
+
+        return f1;
+}
+
 static inline netdev_features_t netdev_get_wanted_features(
         struct net_device *dev)
 {
diff --git a/include/linux/netfilter/nfnetlink_acct.h b/include/linux/netfilter/nfnetlink_acct.h
index b2e85e59f760..6ec975748742 100644
--- a/include/linux/netfilter/nfnetlink_acct.h
+++ b/include/linux/netfilter/nfnetlink_acct.h
@@ -3,11 +3,17 @@
 
 #include <uapi/linux/netfilter/nfnetlink_acct.h>
 
+enum {
+        NFACCT_NO_QUOTA         = -1,
+        NFACCT_UNDERQUOTA,
+        NFACCT_OVERQUOTA,
+};
 
 struct nf_acct;
 
 struct nf_acct *nfnl_acct_find_get(const char *filter_name);
 void nfnl_acct_put(struct nf_acct *acct);
 void nfnl_acct_update(const struct sk_buff *skb, struct nf_acct *nfacct);
-
+extern int nfnl_acct_overquota(const struct sk_buff *skb,
+                              struct nf_acct *nfacct);
 #endif /* _NFNL_ACCT_H */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 034cda789a15..9e572daa15d5 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -46,7 +46,8 @@ struct netlink_kernel_cfg {
         unsigned int    flags;
         void            (*input)(struct sk_buff *skb);
         struct mutex    *cb_mutex;
-        void            (*bind)(int group);
+        int             (*bind)(int group);
+        void            (*unbind)(int group);
         bool            (*compare)(struct net *net, struct sock *sk);
 };
 
diff --git a/include/linux/nl802154.h b/include/linux/nl802154.h
index c8d7f3965fff..20163b9a0eae 100644
--- a/include/linux/nl802154.h
+++ b/include/linux/nl802154.h
@@ -80,6 +80,22 @@ enum {
 
         IEEE802154_ATTR_FRAME_RETRIES,
 
+        IEEE802154_ATTR_LLSEC_ENABLED,
+        IEEE802154_ATTR_LLSEC_SECLEVEL,
+        IEEE802154_ATTR_LLSEC_KEY_MODE,
+        IEEE802154_ATTR_LLSEC_KEY_SOURCE_SHORT,
+        IEEE802154_ATTR_LLSEC_KEY_SOURCE_EXTENDED,
+        IEEE802154_ATTR_LLSEC_KEY_ID,
+        IEEE802154_ATTR_LLSEC_FRAME_COUNTER,
+        IEEE802154_ATTR_LLSEC_KEY_BYTES,
+        IEEE802154_ATTR_LLSEC_KEY_USAGE_FRAME_TYPES,
+        IEEE802154_ATTR_LLSEC_KEY_USAGE_COMMANDS,
+        IEEE802154_ATTR_LLSEC_FRAME_TYPE,
+        IEEE802154_ATTR_LLSEC_CMD_FRAME_ID,
+        IEEE802154_ATTR_LLSEC_SECLEVELS,
+        IEEE802154_ATTR_LLSEC_DEV_OVERRIDE,
+        IEEE802154_ATTR_LLSEC_DEV_KEY_MODE,
+
         __IEEE802154_ATTR_MAX,
 };
 
@@ -134,6 +150,21 @@ enum {
 
         IEEE802154_SET_MACPARAMS,
 
+        IEEE802154_LLSEC_GETPARAMS,
+        IEEE802154_LLSEC_SETPARAMS,
+        IEEE802154_LLSEC_LIST_KEY,
+        IEEE802154_LLSEC_ADD_KEY,
+        IEEE802154_LLSEC_DEL_KEY,
+        IEEE802154_LLSEC_LIST_DEV,
+        IEEE802154_LLSEC_ADD_DEV,
+        IEEE802154_LLSEC_DEL_DEV,
+        IEEE802154_LLSEC_LIST_DEVKEY,
+        IEEE802154_LLSEC_ADD_DEVKEY,
+        IEEE802154_LLSEC_DEL_DEVKEY,
+        IEEE802154_LLSEC_LIST_SECLEVEL,
+        IEEE802154_LLSEC_ADD_SECLEVEL,
+        IEEE802154_LLSEC_DEL_SECLEVEL,
+
         __IEEE802154_CMD_MAX,
 };
 
diff --git a/include/linux/of_mdio.h b/include/linux/of_mdio.h
index 881a7c3571f4..a70c9493d55a 100644
--- a/include/linux/of_mdio.h
+++ b/include/linux/of_mdio.h
@@ -22,12 +22,12 @@ extern struct phy_device *of_phy_connect(struct net_device *dev,
 struct phy_device *of_phy_attach(struct net_device *dev,
                                  struct device_node *phy_np, u32 flags,
                                  phy_interface_t iface);
-extern struct phy_device *of_phy_connect_fixed_link(struct net_device *dev,
-                                         void (*hndlr)(struct net_device *),
-                                         phy_interface_t iface);
 
 extern struct mii_bus *of_mdio_find_bus(struct device_node *mdio_np);
 
+extern void of_mdiobus_link_phydev(struct mii_bus *mdio,
+                                   struct phy_device *phydev);
+
 #else /* CONFIG_OF */
 static inline int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
 {
@@ -59,17 +59,30 @@ static inline struct phy_device *of_phy_attach(struct net_device *dev,
         return NULL;
 }
 
-static inline struct phy_device *of_phy_connect_fixed_link(struct net_device *dev,
-                                                           void (*hndlr)(struct net_device *),
-                                                           phy_interface_t iface)
+static inline struct mii_bus *of_mdio_find_bus(struct device_node *mdio_np)
 {
         return NULL;
 }
 
-static inline struct mii_bus *of_mdio_find_bus(struct device_node *mdio_np)
+static inline void of_mdiobus_link_phydev(struct mii_bus *mdio,
+                                          struct phy_device *phydev)
 {
-        return NULL;
 }
 #endif /* CONFIG_OF */
 
+#if defined(CONFIG_OF) && defined(CONFIG_FIXED_PHY)
+extern int of_phy_register_fixed_link(struct device_node *np);
+extern bool of_phy_is_fixed_link(struct device_node *np);
+#else
+static inline int of_phy_register_fixed_link(struct device_node *np)
+{
+        return -ENOSYS;
+}
+static inline bool of_phy_is_fixed_link(struct device_node *np)
+{
+        return false;
+}
+#endif
+
+
 #endif /* __LINUX_OF_MDIO_H */
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 4d0221fd0688..864ddafad8cc 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -198,6 +198,13 @@ static inline struct mii_bus *mdiobus_alloc(void)
 int mdiobus_register(struct mii_bus *bus);
 void mdiobus_unregister(struct mii_bus *bus);
 void mdiobus_free(struct mii_bus *bus);
+struct mii_bus *devm_mdiobus_alloc_size(struct device *dev, int sizeof_priv);
+static inline struct mii_bus *devm_mdiobus_alloc(struct device *dev)
+{
+        return devm_mdiobus_alloc_size(dev, 0);
+}
+
+void devm_mdiobus_free(struct device *dev, struct mii_bus *bus);
 struct phy_device *mdiobus_scan(struct mii_bus *bus, int addr);
 int mdiobus_read(struct mii_bus *bus, int addr, u32 regnum);
 int mdiobus_write(struct mii_bus *bus, int addr, u32 regnum, u16 val);
@@ -666,6 +673,7 @@ static inline int phy_read_status(struct phy_device *phydev)
         return phydev->drv->read_status(phydev);
 }
 
+int genphy_config_init(struct phy_device *phydev);
 int genphy_setup_forced(struct phy_device *phydev);
 int genphy_restart_aneg(struct phy_device *phydev);
 int genphy_config_aneg(struct phy_device *phydev);
diff --git a/include/linux/phy_fixed.h b/include/linux/phy_fixed.h
index 509d8f5f984e..ae612acebb53 100644
--- a/include/linux/phy_fixed.h
+++ b/include/linux/phy_fixed.h
@@ -9,15 +9,31 @@ struct fixed_phy_status {
         int asym_pause;
 };
 
+struct device_node;
+
 #ifdef CONFIG_FIXED_PHY
 extern int fixed_phy_add(unsigned int irq, int phy_id,
                          struct fixed_phy_status *status);
+extern int fixed_phy_register(unsigned int irq,
+                              struct fixed_phy_status *status,
+                              struct device_node *np);
+extern void fixed_phy_del(int phy_addr);
 #else
 static inline int fixed_phy_add(unsigned int irq, int phy_id,
                                 struct fixed_phy_status *status)
 {
         return -ENODEV;
 }
+static inline int fixed_phy_register(unsigned int irq,
+                                     struct fixed_phy_status *status,
+                                     struct device_node *np)
+{
+        return -ENODEV;
+}
+static inline int fixed_phy_del(int phy_addr)
+{
+        return -ENODEV;
+}
 #endif /* CONFIG_FIXED_PHY */
 
 /*
diff --git a/include/linux/platform_data/st21nfca.h b/include/linux/platform_data/st21nfca.h
new file mode 100644
index 000000000000..1730312398ff
--- /dev/null
+++ b/include/linux/platform_data/st21nfca.h
@@ -0,0 +1,32 @@
+/*
+ * Driver include for the ST21NFCA NFC chip.
+ *
+ * Copyright (C) 2014  STMicroelectronics SAS. All rights reserved.
+ *
+ * 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 that 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/>.
+ */
+
+#ifndef _ST21NFCA_HCI_H_
+#define _ST21NFCA_HCI_H_
+
+#include <linux/i2c.h>
+
+#define ST21NFCA_HCI_DRIVER_NAME "st21nfca_hci"
+
+struct st21nfca_nfc_platform_data {
+        unsigned int gpio_irq;
+        unsigned int gpio_ena;
+        unsigned int irq_polarity;
+};
+
+#endif /* _ST21NFCA_HCI_H_ */
diff --git a/include/linux/rfkill-gpio.h b/include/linux/rfkill-gpio.h
index 4d09f6eab359..20bcb55498cd 100644
--- a/include/linux/rfkill-gpio.h
+++ b/include/linux/rfkill-gpio.h
@@ -27,21 +27,11 @@
  * struct rfkill_gpio_platform_data - platform data for rfkill gpio device.
  * for unused gpio's, the expected value is -1.
  * @name:               name for the gpio rf kill instance
- * @reset_gpio:         GPIO which is used for reseting rfkill switch
- * @shutdown_gpio:      GPIO which is used for shutdown of rfkill switch
- * @power_clk_name:     [optional] name of clk to turn off while blocked
- * @gpio_runtime_close: clean up platform specific gpio configuration
- * @gpio_runtime_setup: set up platform specific gpio configuration
  */
 
 struct rfkill_gpio_platform_data {
         char                    *name;
-        int                     reset_gpio;
-        int                     shutdown_gpio;
-        const char              *power_clk_name;
         enum rfkill_type        type;
-        void    (*gpio_runtime_close)(struct platform_device *);
-        int     (*gpio_runtime_setup)(struct platform_device *);
 };
 
 #endif /* __RFKILL_GPIO_H */
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 08074a810164..5b5cd3189c98 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -345,6 +345,10 @@ enum {
         SKB_GSO_UDP_TUNNEL = 1 << 9,
 
         SKB_GSO_MPLS = 1 << 10,
+
+        SKB_GSO_UDP_TUNNEL_CSUM = 1 << 11,
+
+        SKB_GSO_GRE_CSUM = 1 << 12,
 };
 
 #if BITS_PER_LONG > 32
@@ -426,7 +430,7 @@ static inline u32 skb_mstamp_us_delta(const struct skb_mstamp *t1,
  *      @csum_start: Offset from skb->head where checksumming should start
  *      @csum_offset: Offset from csum_start where checksum should be stored
  *      @priority: Packet queueing priority
- *      @local_df: allow local fragmentation
+ *      @ignore_df: allow local fragmentation
  *      @cloned: Head may be cloned (check refcnt to be sure)
  *      @ip_summed: Driver fed us an IP checksum
  *      @nohdr: Payload reference only, must not modify header
@@ -514,7 +518,7 @@ struct sk_buff {
         };
         __u32                   priority;
         kmemcheck_bitfield_begin(flags1);
-        __u8                    local_df:1,
+        __u8                    ignore_df:1,
                                 cloned:1,
                                 ip_summed:2,
                                 nohdr:1,
@@ -567,7 +571,10 @@ struct sk_buff {
          * headers if needed
          */
         __u8                    encapsulation:1;
-        /* 6/8 bit hole (depending on ndisc_nodetype presence) */
+        __u8                    encap_hdr_csum:1;
+        __u8                    csum_valid:1;
+        __u8                    csum_complete_sw:1;
+        /* 3/5 bit hole (depending on ndisc_nodetype presence) */
         kmemcheck_bitfield_end(flags2);
 
 #if defined CONFIG_NET_DMA || defined CONFIG_NET_RX_BUSY_POLL
@@ -739,7 +746,13 @@ struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
 int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t priority);
 struct sk_buff *skb_copy(const struct sk_buff *skb, gfp_t priority);
-struct sk_buff *__pskb_copy(struct sk_buff *skb, int headroom, gfp_t gfp_mask);
+struct sk_buff *__pskb_copy_fclone(struct sk_buff *skb, int headroom,
+                                   gfp_t gfp_mask, bool fclone);
+static inline struct sk_buff *__pskb_copy(struct sk_buff *skb, int headroom,
+                                          gfp_t gfp_mask)
+{
+        return __pskb_copy_fclone(skb, headroom, gfp_mask, false);
+}
 
 int pskb_expand_head(struct sk_buff *skb, int nhead, int ntail, gfp_t gfp_mask);
 struct sk_buff *skb_realloc_headroom(struct sk_buff *skb,
@@ -2233,6 +2246,14 @@ static inline struct sk_buff *pskb_copy(struct sk_buff *skb,
         return __pskb_copy(skb, skb_headroom(skb), gfp_mask);
 }
 
+
+static inline struct sk_buff *pskb_copy_for_clone(struct sk_buff *skb,
+                                                  gfp_t gfp_mask)
+{
+        return __pskb_copy_fclone(skb, skb_headroom(skb), gfp_mask, true);
+}
+
+
 /**
  *      skb_clone_writable - is the header of a clone writable
  *      @skb: buffer to check
@@ -2716,7 +2737,7 @@ __sum16 __skb_checksum_complete(struct sk_buff *skb);
 
 static inline int skb_csum_unnecessary(const struct sk_buff *skb)
 {
-        return skb->ip_summed & CHECKSUM_UNNECESSARY;
+        return ((skb->ip_summed & CHECKSUM_UNNECESSARY) || skb->csum_valid);
 }
 
 /**
@@ -2741,6 +2762,103 @@ static inline __sum16 skb_checksum_complete(struct sk_buff *skb)
                0 : __skb_checksum_complete(skb);
 }
 
+/* Check if we need to perform checksum complete validation.
+ *
+ * Returns true if checksum complete is needed, false otherwise
+ * (either checksum is unnecessary or zero checksum is allowed).
+ */
+static inline bool __skb_checksum_validate_needed(struct sk_buff *skb,
+                                                  bool zero_okay,
+                                                  __sum16 check)
+{
+        if (skb_csum_unnecessary(skb) || (zero_okay && !check)) {
+                skb->csum_valid = 1;
+                return false;
+        }
+
+        return true;
+}
+
+/* For small packets <= CHECKSUM_BREAK peform checksum complete directly
+ * in checksum_init.
+ */
+#define CHECKSUM_BREAK 76
+
+/* Validate (init) checksum based on checksum complete.
+ *
+ * Return values:
+ *   0: checksum is validated or try to in skb_checksum_complete. In the latter
+ *      case the ip_summed will not be CHECKSUM_UNNECESSARY and the pseudo
+ *      checksum is stored in skb->csum for use in __skb_checksum_complete
+ *   non-zero: value of invalid checksum
+ *
+ */
+static inline __sum16 __skb_checksum_validate_complete(struct sk_buff *skb,
+                                                       bool complete,
+                                                       __wsum psum)
+{
+        if (skb->ip_summed == CHECKSUM_COMPLETE) {
+                if (!csum_fold(csum_add(psum, skb->csum))) {
+                        skb->csum_valid = 1;
+                        return 0;
+                }
+        }
+
+        skb->csum = psum;
+
+        if (complete || skb->len <= CHECKSUM_BREAK) {
+                __sum16 csum;
+
+                csum = __skb_checksum_complete(skb);
+                skb->csum_valid = !csum;
+                return csum;
+        }
+
+        return 0;
+}
+
+static inline __wsum null_compute_pseudo(struct sk_buff *skb, int proto)
+{
+        return 0;
+}
+
+/* Perform checksum validate (init). Note that this is a macro since we only
+ * want to calculate the pseudo header which is an input function if necessary.
+ * First we try to validate without any computation (checksum unnecessary) and
+ * then calculate based on checksum complete calling the function to compute
+ * pseudo header.
+ *
+ * Return values:
+ *   0: checksum is validated or try to in skb_checksum_complete
+ *   non-zero: value of invalid checksum
+ */
+#define __skb_checksum_validate(skb, proto, complete,                   \
+                                zero_okay, check, compute_pseudo)       \
+({                                                                      \
+        __sum16 __ret = 0;                                              \
+        skb->csum_valid = 0;                                            \
+        if (__skb_checksum_validate_needed(skb, zero_okay, check))      \
+                __ret = __skb_checksum_validate_complete(skb,           \
+                                complete, compute_pseudo(skb, proto));  \
+        __ret;                                                          \
+})
+
+#define skb_checksum_init(skb, proto, compute_pseudo)                   \
+        __skb_checksum_validate(skb, proto, false, false, 0, compute_pseudo)
+
+#define skb_checksum_init_zero_check(skb, proto, check, compute_pseudo) \
+        __skb_checksum_validate(skb, proto, false, true, check, compute_pseudo)
+
+#define skb_checksum_validate(skb, proto, compute_pseudo)               \
+        __skb_checksum_validate(skb, proto, true, false, 0, compute_pseudo)
+
+#define skb_checksum_validate_zero_check(skb, proto, check,             \
+                                         compute_pseudo)                \
+        __skb_checksum_validate_(skb, proto, true, true, check, compute_pseudo)
+
+#define skb_checksum_simple_validate(skb)                               \
+        __skb_checksum_validate(skb, 0, true, false, 0, null_compute_pseudo)
+
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 void nf_conntrack_destroy(struct nf_conntrack *nfct);
 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
@@ -2895,6 +3013,7 @@ static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
 struct skb_gso_cb {
         int     mac_offset;
         int     encap_level;
+        __u16   csum_start;
 };
 #define SKB_GSO_CB(skb) ((struct skb_gso_cb *)(skb)->cb)
 
@@ -2919,6 +3038,28 @@ static inline int gso_pskb_expand_head(struct sk_buff *skb, int extra)
         return 0;
 }
 
+/* Compute the checksum for a gso segment. First compute the checksum value
+ * from the start of transport header to SKB_GSO_CB(skb)->csum_start, and
+ * then add in skb->csum (checksum from csum_start to end of packet).
+ * skb->csum and csum_start are then updated to reflect the checksum of the
+ * resultant packet starting from the transport header-- the resultant checksum
+ * is in the res argument (i.e. normally zero or ~ of checksum of a pseudo
+ * header.
+ */
+static inline __sum16 gso_make_checksum(struct sk_buff *skb, __wsum res)
+{
+        int plen = SKB_GSO_CB(skb)->csum_start - skb_headroom(skb) -
+            skb_transport_offset(skb);
+        __u16 csum;
+
+        csum = csum_fold(csum_partial(skb_transport_header(skb),
+                                      plen, skb->csum));
+        skb->csum = res;
+        SKB_GSO_CB(skb)->csum_start -= plen;
+
+        return csum;
+}
+
 static inline bool skb_is_gso(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_size;
diff --git a/include/linux/spi/at86rf230.h b/include/linux/spi/at86rf230.h
index aa327a8105ad..b2b1afbb3202 100644
--- a/include/linux/spi/at86rf230.h
+++ b/include/linux/spi/at86rf230.h
@@ -26,20 +26,6 @@ struct at86rf230_platform_data {
         int rstn;
         int slp_tr;
         int dig2;
-
-        /* Setting the irq_type will configure the driver to request
-         * the platform irq trigger type according to the given value
-         * and configure the interrupt polarity of the device to the
-         * corresponding polarity.
-         *
-         * Allowed values are: IRQF_TRIGGER_RISING, IRQF_TRIGGER_FALLING,
-         *                     IRQF_TRIGGER_HIGH and IRQF_TRIGGER_LOW
-         *
-         * Setting it to 0, the driver does not touch the trigger type
-         * configuration of the interrupt and sets the interrupt polarity
-         * of the device to high active (the default value).
-         */
-        int irq_type;
 };
 
 #endif
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 07ef9b82b66d..4568a5cc9ab8 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -33,6 +33,7 @@ struct ssb_sprom {
         u8 et1phyaddr;          /* MII address for enet1 */
         u8 et0mdcport;          /* MDIO for enet0 */
         u8 et1mdcport;          /* MDIO for enet1 */
+        u16 dev_id;             /* Device ID overriding e.g. PCI ID */
         u16 board_rev;          /* Board revision number from SPROM. */
         u16 board_num;          /* Board number from SPROM. */
         u16 board_type;         /* Board type from SPROM. */
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 239946868142..a0513210798f 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -197,7 +197,8 @@ struct tcp_sock {
         u8      do_early_retrans:1,/* Enable RFC5827 early-retransmit  */
                 syn_data:1,     /* SYN includes data */
                 syn_fastopen:1, /* SYN includes Fast Open option */
-                syn_data_acked:1;/* data in SYN is acked by SYN-ACK */
+                syn_data_acked:1,/* data in SYN is acked by SYN-ACK */
+                is_cwnd_limited:1;/* forward progress limited by snd_cwnd? */
         u32     tlp_high_seq;   /* snd_nxt at the time of TLP retransmit. */
 
 /* RTT measurement */
@@ -209,6 +210,8 @@ struct tcp_sock {
 
         u32     packets_out;    /* Packets which are "in flight"        */
         u32     retrans_out;    /* Retransmitted packets out            */
+        u32     max_packets_out;  /* max packets_out in last window */
+        u32     max_packets_seq;  /* right edge of max_packets_out flight */
 
         u16     urg_data;       /* Saved octet of OOB data and control flags */
         u8      ecn_flags;      /* ECN status bits.                     */
@@ -365,11 +368,6 @@ static inline bool tcp_passive_fastopen(const struct sock *sk)
                 tcp_sk(sk)->fastopen_rsk != NULL);
 }
 
-static inline bool fastopen_cookie_present(struct tcp_fastopen_cookie *foc)
-{
-        return foc->len != -1;
-}
-
 extern void tcp_sock_destruct(struct sock *sk);
 
 static inline int fastopen_init_queue(struct sock *sk, int backlog)
diff --git a/include/linux/udp.h b/include/linux/udp.h
index 42278bbf7a88..247cfdcc4b08 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -47,7 +47,9 @@ struct udp_sock {
 #define udp_portaddr_node       inet.sk.__sk_common.skc_portaddr_node
         int              pending;       /* Any pending frames ? */
         unsigned int     corkflag;      /* Cork is required */
-        __u16            encap_type;    /* Is this an Encapsulation socket? */
+        __u8             encap_type;    /* Is this an Encapsulation socket? */
+        unsigned char    no_check6_tx:1,/* Send zero UDP6 checksums on TX? */
+                         no_check6_rx:1;/* Allow zero UDP6 checksums on RX? */
         /*
          * Following member retains the information to create a UDP header
          * when the socket is uncorked.
@@ -76,6 +78,26 @@ static inline struct udp_sock *udp_sk(const struct sock *sk)
         return (struct udp_sock *)sk;
 }
 
+static inline void udp_set_no_check6_tx(struct sock *sk, bool val)
+{
+        udp_sk(sk)->no_check6_tx = val;
+}
+
+static inline void udp_set_no_check6_rx(struct sock *sk, bool val)
+{
+        udp_sk(sk)->no_check6_rx = val;
+}
+
+static inline bool udp_get_no_check6_tx(struct sock *sk)
+{
+        return udp_sk(sk)->no_check6_tx;
+}
+
+static inline bool udp_get_no_check6_rx(struct sock *sk)
+{
+        return udp_sk(sk)->no_check6_rx;
+}
+
 #define udp_portaddr_for_each_entry(__sk, node, list) \
         hlist_nulls_for_each_entry(__sk, node, list, __sk_common.skc_portaddr_node)
 
diff --git a/include/linux/usb/cdc_ncm.h b/include/linux/usb/cdc_ncm.h
index 44b38b92236a..7c9b484735c5 100644
--- a/include/linux/usb/cdc_ncm.h
+++ b/include/linux/usb/cdc_ncm.h
@@ -52,6 +52,10 @@
 #define CDC_NCM_NTB_MAX_SIZE_TX                 32768   /* bytes */
 #define CDC_NCM_NTB_MAX_SIZE_RX                 32768   /* bytes */
 
+/* Initial NTB length */
+#define CDC_NCM_NTB_DEF_SIZE_TX                 16384   /* bytes */
+#define CDC_NCM_NTB_DEF_SIZE_RX                 16384   /* bytes */
+
 /* Minimum value for MaxDatagramSize, ch. 6.2.9 */
 #define CDC_NCM_MIN_DATAGRAM_SIZE               1514    /* bytes */
 
@@ -72,16 +76,9 @@
 /* Restart the timer, if amount of datagrams is less than given value */
 #define CDC_NCM_RESTART_TIMER_DATAGRAM_CNT      3
 #define CDC_NCM_TIMER_PENDING_CNT               2
-#define CDC_NCM_TIMER_INTERVAL                  (400UL * NSEC_PER_USEC)
-
-/* The following macro defines the minimum header space */
-#define CDC_NCM_MIN_HDR_SIZE \
-        (sizeof(struct usb_cdc_ncm_nth16) + sizeof(struct usb_cdc_ncm_ndp16) + \
-        (CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16))
-
-#define CDC_NCM_NDP_SIZE \
-        (sizeof(struct usb_cdc_ncm_ndp16) +                             \
-              (CDC_NCM_DPT_DATAGRAMS_MAX + 1) * sizeof(struct usb_cdc_ncm_dpe16))
+#define CDC_NCM_TIMER_INTERVAL_USEC             400UL
+#define CDC_NCM_TIMER_INTERVAL_MIN              5UL
+#define CDC_NCM_TIMER_INTERVAL_MAX              (U32_MAX / NSEC_PER_USEC)
 
 #define cdc_ncm_comm_intf_is_mbim(x)  ((x)->desc.bInterfaceSubClass == USB_CDC_SUBCLASS_MBIM && \
                                        (x)->desc.bInterfaceProtocol == USB_CDC_PROTO_NONE)
@@ -107,6 +104,9 @@ struct cdc_ncm_ctx {
         spinlock_t mtx;
         atomic_t stop;
 
+        u32 timer_interval;
+        u32 max_ndp_size;
+
         u32 tx_timer_pending;
         u32 tx_curr_frame_num;
         u32 rx_max;
@@ -118,10 +118,21 @@ struct cdc_ncm_ctx {
         u16 tx_ndp_modulus;
         u16 tx_seq;
         u16 rx_seq;
-        u16 connected;
+        u16 min_tx_pkt;
+
+        /* statistics */
+        u32 tx_curr_frame_payload;
+        u32 tx_reason_ntb_full;
+        u32 tx_reason_ndp_full;
+        u32 tx_reason_timeout;
+        u32 tx_reason_max_datagram;
+        u64 tx_overhead;
+        u64 tx_ntbs;
+        u64 rx_overhead;
+        u64 rx_ntbs;
 };
 
-u8 cdc_ncm_select_altsetting(struct usbnet *dev, struct usb_interface *intf);
+u8 cdc_ncm_select_altsetting(struct usb_interface *intf);
 int cdc_ncm_bind_common(struct usbnet *dev, struct usb_interface *intf, u8 data_altsetting);
 void cdc_ncm_unbind(struct usbnet *dev, struct usb_interface *intf);
 struct sk_buff *cdc_ncm_fill_tx_frame(struct usbnet *dev, struct sk_buff *skb, __le32 sign);
diff --git a/include/net/6lowpan.h b/include/net/6lowpan.h
index f7d372b7d4ff..79b530fb2c4d 100644
--- a/include/net/6lowpan.h
+++ b/include/net/6lowpan.h
@@ -54,6 +54,7 @@
 #define __6LOWPAN_H__
 
 #include <net/ipv6.h>
+#include <net/net_namespace.h>
 
 #define UIP_802154_SHORTADDR_LEN        2  /* compressed ipv6 address length */
 #define UIP_IPH_LEN                     40 /* ipv6 fixed header size */
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index 933a9f22a05f..f679877bb601 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -306,11 +306,6 @@ static inline void addrconf_addr_solict_mult(const struct in6_addr *addr,
                       htonl(0xFF000000) | addr->s6_addr32[3]);
 }
 
-static inline bool ipv6_addr_is_multicast(const struct in6_addr *addr)
-{
-        return (addr->s6_addr32[0] & htonl(0xFF000000)) == htonl(0xFF000000);
-}
-
 static inline bool ipv6_addr_is_ll_all_nodes(const struct in6_addr *addr)
 {
 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
diff --git a/include/net/af_ieee802154.h b/include/net/af_ieee802154.h
index f79ae2aa76d6..085940f7eeec 100644
--- a/include/net/af_ieee802154.h
+++ b/include/net/af_ieee802154.h
@@ -57,6 +57,14 @@ struct sockaddr_ieee802154 {
 /* get/setsockopt */
 #define SOL_IEEE802154  0
 
-#define WPAN_WANTACK    0
+#define WPAN_WANTACK            0
+#define WPAN_SECURITY           1
+#define WPAN_SECURITY_LEVEL     2
+
+#define WPAN_SECURITY_DEFAULT   0
+#define WPAN_SECURITY_OFF       1
+#define WPAN_SECURITY_ON        2
+
+#define WPAN_SECURITY_LEVEL_DEFAULT     (-1)
 
 #endif
diff --git a/include/net/bluetooth/hci.h b/include/net/bluetooth/hci.h
index be150cf8cd43..16587dcd6a91 100644
--- a/include/net/bluetooth/hci.h
+++ b/include/net/bluetooth/hci.h
@@ -367,6 +367,7 @@ enum {
 #define HCI_ERROR_REMOTE_POWER_OFF      0x15
 #define HCI_ERROR_LOCAL_HOST_TERM       0x16
 #define HCI_ERROR_PAIRING_NOT_ALLOWED   0x18
+#define HCI_ERROR_ADVERTISING_TIMEOUT   0x3c
 
 /* Flow control modes */
 #define HCI_FLOW_CTL_MODE_PACKET_BASED  0x00
@@ -1053,6 +1054,17 @@ struct hci_cp_write_page_scan_activity {
         __le16   window;
 } __packed;
 
+#define HCI_OP_READ_TX_POWER            0x0c2d
+struct hci_cp_read_tx_power {
+        __le16   handle;
+        __u8     type;
+} __packed;
+struct hci_rp_read_tx_power {
+        __u8     status;
+        __le16   handle;
+        __s8     tx_power;
+} __packed;
+
 #define HCI_OP_READ_PAGE_SCAN_TYPE      0x0c46
 struct hci_rp_read_page_scan_type {
         __u8     status;
@@ -1063,6 +1075,16 @@ struct hci_rp_read_page_scan_type {
         #define PAGE_SCAN_TYPE_STANDARD         0x00
         #define PAGE_SCAN_TYPE_INTERLACED       0x01
 
+#define HCI_OP_READ_RSSI                0x1405
+struct hci_cp_read_rssi {
+        __le16   handle;
+} __packed;
+struct hci_rp_read_rssi {
+        __u8     status;
+        __le16   handle;
+        __s8     rssi;
+} __packed;
+
 #define HCI_OP_READ_LOCAL_AMP_INFO      0x1409
 struct hci_rp_read_local_amp_info {
         __u8     status;
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 5f8bc05694ac..b386bf17e6c2 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -68,6 +68,11 @@ struct discovery_state {
         struct list_head        unknown;        /* Name state not known */
         struct list_head        resolve;        /* Name needs to be resolved */
         __u32                   timestamp;
+        bdaddr_t                last_adv_addr;
+        u8                      last_adv_addr_type;
+        s8                      last_adv_rssi;
+        u8                      last_adv_data[HCI_MAX_AD_LENGTH];
+        u8                      last_adv_data_len;
 };
 
 struct hci_conn_hash {
@@ -140,6 +145,10 @@ struct oob_data {
 /* Default LE RPA expiry time, 15 minutes */
 #define HCI_DEFAULT_RPA_TIMEOUT         (15 * 60)
 
+/* Default min/max age of connection information (1s/3s) */
+#define DEFAULT_CONN_INFO_MIN_AGE       1000
+#define DEFAULT_CONN_INFO_MAX_AGE       3000
+
 struct amp_assoc {
         __u16   len;
         __u16   offset;
@@ -194,6 +203,9 @@ struct hci_dev {
         __u16           le_scan_window;
         __u16           le_conn_min_interval;
         __u16           le_conn_max_interval;
+        __u16           discov_interleaved_timeout;
+        __u16           conn_info_min_age;
+        __u16           conn_info_max_age;
         __u8            ssp_debug_mode;
 
         __u16           devid_source;
@@ -368,8 +380,13 @@ struct hci_conn {
         __u16           setting;
         __u16           le_conn_min_interval;
         __u16           le_conn_max_interval;
+        __s8            rssi;
+        __s8            tx_power;
+        __s8            max_tx_power;
         unsigned long   flags;
 
+        unsigned long   conn_info_timestamp;
+
         __u8            remote_cap;
         __u8            remote_auth;
         __u8            remote_id;
@@ -1204,8 +1221,8 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event);
  */
 #define DISCOV_LE_SCAN_WIN              0x12
 #define DISCOV_LE_SCAN_INT              0x12
-#define DISCOV_LE_TIMEOUT               msecs_to_jiffies(10240)
-#define DISCOV_INTERLEAVED_TIMEOUT      msecs_to_jiffies(5120)
+#define DISCOV_LE_TIMEOUT               10240   /* msec */
+#define DISCOV_INTERLEAVED_TIMEOUT      5120    /* msec */
 #define DISCOV_INTERLEAVED_INQUIRY_LEN  0x04
 #define DISCOV_BREDR_INQUIRY_LEN        0x08
 
@@ -1265,7 +1282,8 @@ void mgmt_read_local_oob_data_complete(struct hci_dev *hdev, u8 *hash192,
                                        u8 *randomizer256, u8 status);
 void mgmt_device_found(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
                        u8 addr_type, u8 *dev_class, s8 rssi, u8 cfm_name,
-                       u8 ssp, u8 *eir, u16 eir_len);
+                       u8 ssp, u8 *eir, u16 eir_len, u8 *scan_rsp,
+                       u8 scan_rsp_len);
 void mgmt_remote_name(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 link_type,
                       u8 addr_type, s8 rssi, u8 *name, u8 name_len);
 void mgmt_discovering(struct hci_dev *hdev, u8 discovering);
diff --git a/include/net/bluetooth/mgmt.h b/include/net/bluetooth/mgmt.h
index d4b571c2f9fd..bcffc9ae0c89 100644
--- a/include/net/bluetooth/mgmt.h
+++ b/include/net/bluetooth/mgmt.h
@@ -181,6 +181,9 @@ struct mgmt_cp_load_link_keys {
 } __packed;
 #define MGMT_LOAD_LINK_KEYS_SIZE        3
 
+#define MGMT_LTK_UNAUTHENTICATED        0x00
+#define MGMT_LTK_AUTHENTICATED          0x01
+
 struct mgmt_ltk_info {
         struct mgmt_addr_info addr;
         __u8    type;
@@ -409,6 +412,18 @@ struct mgmt_cp_load_irks {
 } __packed;
 #define MGMT_LOAD_IRKS_SIZE             2
 
+#define MGMT_OP_GET_CONN_INFO           0x0031
+struct mgmt_cp_get_conn_info {
+        struct mgmt_addr_info addr;
+} __packed;
+#define MGMT_GET_CONN_INFO_SIZE         MGMT_ADDR_INFO_SIZE
+struct mgmt_rp_get_conn_info {
+        struct mgmt_addr_info addr;
+        __s8    rssi;
+        __s8    tx_power;
+        __s8    max_tx_power;
+} __packed;
+
 #define MGMT_EV_CMD_COMPLETE            0x0001
 struct mgmt_ev_cmd_complete {
         __le16  opcode;
diff --git a/include/net/bluetooth/rfcomm.h b/include/net/bluetooth/rfcomm.h
index 2611cc389d7d..578b83127af1 100644
--- a/include/net/bluetooth/rfcomm.h
+++ b/include/net/bluetooth/rfcomm.h
@@ -173,7 +173,7 @@ struct rfcomm_dlc {
         struct sk_buff_head   tx_queue;
         struct timer_list     timer;
 
-        spinlock_t    lock;
+        struct mutex  lock;
         unsigned long state;
         unsigned long flags;
         atomic_t      refcnt;
@@ -244,8 +244,8 @@ int  rfcomm_dlc_get_modem_status(struct rfcomm_dlc *d, u8 *v24_sig);
 void rfcomm_dlc_accept(struct rfcomm_dlc *d);
 struct rfcomm_dlc *rfcomm_dlc_exists(bdaddr_t *src, bdaddr_t *dst, u8 channel);
 
-#define rfcomm_dlc_lock(d)     spin_lock(&d->lock)
-#define rfcomm_dlc_unlock(d)   spin_unlock(&d->lock)
+#define rfcomm_dlc_lock(d)     mutex_lock(&d->lock)
+#define rfcomm_dlc_unlock(d)   mutex_unlock(&d->lock)
 
 static inline void rfcomm_dlc_hold(struct rfcomm_dlc *d)
 {
diff --git a/include/net/cfg80211.h b/include/net/cfg80211.h
index f856e5a746fa..e46c437944f7 100644
--- a/include/net/cfg80211.h
+++ b/include/net/cfg80211.h
@@ -109,6 +109,13 @@ enum ieee80211_band {
  *      channel as the control or any of the secondary channels.
  *      This may be due to the driver or due to regulatory bandwidth
  *      restrictions.
+ * @IEEE80211_CHAN_INDOOR_ONLY: see %NL80211_FREQUENCY_ATTR_INDOOR_ONLY
+ * @IEEE80211_CHAN_GO_CONCURRENT: see %NL80211_FREQUENCY_ATTR_GO_CONCURRENT
+ * @IEEE80211_CHAN_NO_20MHZ: 20 MHz bandwidth is not permitted
+ *      on this channel.
+ * @IEEE80211_CHAN_NO_10MHZ: 10 MHz bandwidth is not permitted
+ *      on this channel.
+ *
  */
 enum ieee80211_channel_flags {
         IEEE80211_CHAN_DISABLED         = 1<<0,
@@ -120,6 +127,10 @@ enum ieee80211_channel_flags {
         IEEE80211_CHAN_NO_OFDM          = 1<<6,
         IEEE80211_CHAN_NO_80MHZ         = 1<<7,
         IEEE80211_CHAN_NO_160MHZ        = 1<<8,
+        IEEE80211_CHAN_INDOOR_ONLY      = 1<<9,
+        IEEE80211_CHAN_GO_CONCURRENT    = 1<<10,
+        IEEE80211_CHAN_NO_20MHZ         = 1<<11,
+        IEEE80211_CHAN_NO_10MHZ         = 1<<12,
 };
 
 #define IEEE80211_CHAN_NO_HT40 \
@@ -330,8 +341,8 @@ struct vif_params {
  * @seq_len: length of @seq.
  */
 struct key_params {
-        u8 *key;
-        u8 *seq;
+        const u8 *key;
+        const u8 *seq;
         int key_len;
         int seq_len;
         u32 cipher;
@@ -441,10 +452,13 @@ bool cfg80211_chandef_usable(struct wiphy *wiphy,
  * cfg80211_chandef_dfs_required - checks if radar detection is required
  * @wiphy: the wiphy to validate against
  * @chandef: the channel definition to check
- * Return: 1 if radar detection is required, 0 if it is not, < 0 on error
+ * @iftype: the interface type as specified in &enum nl80211_iftype
+ * Returns:
+ *      1 if radar detection is required, 0 if it is not, < 0 on error
  */
 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
-                                  const struct cfg80211_chan_def *chandef);
+                                  const struct cfg80211_chan_def *chandef,
+                                  enum nl80211_iftype iftype);
 
 /**
  * ieee80211_chandef_rate_flags - returns rate flags for a channel
@@ -654,7 +668,6 @@ struct cfg80211_acl_data {
  * @p2p_opp_ps: P2P opportunistic PS
  * @acl: ACL configuration used by the drivers which has support for
  *      MAC address based access control
- * @radar_required: set if radar detection is required
  */
 struct cfg80211_ap_settings {
         struct cfg80211_chan_def chandef;
@@ -672,7 +685,6 @@ struct cfg80211_ap_settings {
         u8 p2p_ctwindow;
         bool p2p_opp_ps;
         const struct cfg80211_acl_data *acl;
-        bool radar_required;
 };
 
 /**
@@ -682,8 +694,10 @@ struct cfg80211_ap_settings {
  *
  * @chandef: defines the channel to use after the switch
  * @beacon_csa: beacon data while performing the switch
- * @counter_offset_beacon: offset for the counter within the beacon (tail)
- * @counter_offset_presp: offset for the counter within the probe response
+ * @counter_offsets_beacon: offsets of the counters within the beacon (tail)
+ * @counter_offsets_presp: offsets of the counters within the probe response
+ * @n_counter_offsets_beacon: number of csa counters the beacon (tail)
+ * @n_counter_offsets_presp: number of csa counters in the probe response
  * @beacon_after: beacon data to be used on the new channel
  * @radar_required: whether radar detection is required on the new channel
  * @block_tx: whether transmissions should be blocked while changing
@@ -692,7 +706,10 @@ struct cfg80211_ap_settings {
 struct cfg80211_csa_settings {
         struct cfg80211_chan_def chandef;
         struct cfg80211_beacon_data beacon_csa;
-        u16 counter_offset_beacon, counter_offset_presp;
+        const u16 *counter_offsets_beacon;
+        const u16 *counter_offsets_presp;
+        unsigned int n_counter_offsets_beacon;
+        unsigned int n_counter_offsets_presp;
         struct cfg80211_beacon_data beacon_after;
         bool radar_required;
         bool block_tx;
@@ -856,36 +873,38 @@ int cfg80211_check_station_change(struct wiphy *wiphy,
  * @STATION_INFO_NONPEER_PM: @nonpeer_pm filled
  * @STATION_INFO_CHAIN_SIGNAL: @chain_signal filled
  * @STATION_INFO_CHAIN_SIGNAL_AVG: @chain_signal_avg filled
+ * @STATION_INFO_EXPECTED_THROUGHPUT: @expected_throughput filled
  */
 enum station_info_flags {
-        STATION_INFO_INACTIVE_TIME      = 1<<0,
-        STATION_INFO_RX_BYTES           = 1<<1,
-        STATION_INFO_TX_BYTES           = 1<<2,
-        STATION_INFO_LLID               = 1<<3,
-        STATION_INFO_PLID               = 1<<4,
-        STATION_INFO_PLINK_STATE        = 1<<5,
-        STATION_INFO_SIGNAL             = 1<<6,
-        STATION_INFO_TX_BITRATE         = 1<<7,
-        STATION_INFO_RX_PACKETS         = 1<<8,
-        STATION_INFO_TX_PACKETS         = 1<<9,
-        STATION_INFO_TX_RETRIES         = 1<<10,
-        STATION_INFO_TX_FAILED          = 1<<11,
-        STATION_INFO_RX_DROP_MISC       = 1<<12,
-        STATION_INFO_SIGNAL_AVG         = 1<<13,
-        STATION_INFO_RX_BITRATE         = 1<<14,
-        STATION_INFO_BSS_PARAM          = 1<<15,
-        STATION_INFO_CONNECTED_TIME     = 1<<16,
-        STATION_INFO_ASSOC_REQ_IES      = 1<<17,
-        STATION_INFO_STA_FLAGS          = 1<<18,
-        STATION_INFO_BEACON_LOSS_COUNT  = 1<<19,
-        STATION_INFO_T_OFFSET           = 1<<20,
-        STATION_INFO_LOCAL_PM           = 1<<21,
-        STATION_INFO_PEER_PM            = 1<<22,
-        STATION_INFO_NONPEER_PM         = 1<<23,
-        STATION_INFO_RX_BYTES64         = 1<<24,
-        STATION_INFO_TX_BYTES64         = 1<<25,
-        STATION_INFO_CHAIN_SIGNAL       = 1<<26,
-        STATION_INFO_CHAIN_SIGNAL_AVG   = 1<<27,
+        STATION_INFO_INACTIVE_TIME              = BIT(0),
+        STATION_INFO_RX_BYTES                   = BIT(1),
+        STATION_INFO_TX_BYTES                   = BIT(2),
+        STATION_INFO_LLID                       = BIT(3),
+        STATION_INFO_PLID                       = BIT(4),
+        STATION_INFO_PLINK_STATE                = BIT(5),
+        STATION_INFO_SIGNAL                     = BIT(6),
+        STATION_INFO_TX_BITRATE                 = BIT(7),
+        STATION_INFO_RX_PACKETS                 = BIT(8),
+        STATION_INFO_TX_PACKETS                 = BIT(9),
+        STATION_INFO_TX_RETRIES                 = BIT(10),
+        STATION_INFO_TX_FAILED                  = BIT(11),
+        STATION_INFO_RX_DROP_MISC               = BIT(12),
+        STATION_INFO_SIGNAL_AVG                 = BIT(13),
+        STATION_INFO_RX_BITRATE                 = BIT(14),
+        STATION_INFO_BSS_PARAM                  = BIT(15),
+        STATION_INFO_CONNECTED_TIME             = BIT(16),
+        STATION_INFO_ASSOC_REQ_IES              = BIT(17),
+        STATION_INFO_STA_FLAGS                  = BIT(18),
+        STATION_INFO_BEACON_LOSS_COUNT          = BIT(19),
+        STATION_INFO_T_OFFSET                   = BIT(20),
+        STATION_INFO_LOCAL_PM                   = BIT(21),
+        STATION_INFO_PEER_PM                    = BIT(22),
+        STATION_INFO_NONPEER_PM                 = BIT(23),
+        STATION_INFO_RX_BYTES64                 = BIT(24),
+        STATION_INFO_TX_BYTES64                 = BIT(25),
+        STATION_INFO_CHAIN_SIGNAL               = BIT(26),
+        STATION_INFO_CHAIN_SIGNAL_AVG           = BIT(27),
+        STATION_INFO_EXPECTED_THROUGHPUT        = BIT(28),
 };
 
 /**
@@ -1007,6 +1026,8 @@ struct sta_bss_parameters {
  * @local_pm: local mesh STA power save mode
  * @peer_pm: peer mesh STA power save mode
  * @nonpeer_pm: non-peer mesh STA power save mode
+ * @expected_throughput: expected throughput in kbps (including 802.11 headers)
+ *      towards this station.
  */
 struct station_info {
         u32 filled;
@@ -1045,6 +1066,8 @@ struct station_info {
         enum nl80211_mesh_power_mode peer_pm;
         enum nl80211_mesh_power_mode nonpeer_pm;
 
+        u32 expected_throughput;
+
         /*
          * Note: Add a new enum station_info_flags value for each new field and
          * use it to check which fields are initialized.
@@ -1052,6 +1075,19 @@ struct station_info {
 };
 
 /**
+ * cfg80211_get_station - retrieve information about a given station
+ * @dev: the device where the station is supposed to be connected to
+ * @mac_addr: the mac address of the station of interest
+ * @sinfo: pointer to the structure to fill with the information
+ *
+ * Returns 0 on success and sinfo is filled with the available information
+ * otherwise returns a negative error code and the content of sinfo has to be
+ * considered undefined.
+ */
+int cfg80211_get_station(struct net_device *dev, const u8 *mac_addr,
+                         struct station_info *sinfo);
+
+/**
  * enum monitor_flags - monitor flags
  *
  * Monitor interface configuration flags. Note that these must be the bits
@@ -1152,7 +1188,7 @@ struct bss_parameters {
         int use_cts_prot;
         int use_short_preamble;
         int use_short_slot_time;
-        u8 *basic_rates;
+        const u8 *basic_rates;
         u8 basic_rates_len;
         int ap_isolate;
         int ht_opmode;
@@ -1682,10 +1718,10 @@ struct cfg80211_disassoc_request {
  * @ht_capa_mask:  The bits of ht_capa which are to be used.
  */
 struct cfg80211_ibss_params {
-        u8 *ssid;
-        u8 *bssid;
+        const u8 *ssid;
+        const u8 *bssid;
         struct cfg80211_chan_def chandef;
-        u8 *ie;
+        const u8 *ie;
         u8 ssid_len, ie_len;
         u16 beacon_interval;
         u32 basic_rates;
@@ -1794,8 +1830,8 @@ struct cfg80211_bitrate_mask {
  * @pmkid: The PMK material itself.
  */
 struct cfg80211_pmksa {
-        u8 *bssid;
-        u8 *pmkid;
+        const u8 *bssid;
+        const u8 *pmkid;
 };
 
 /**
@@ -1810,7 +1846,7 @@ struct cfg80211_pmksa {
  * memory, free @mask only!
  */
 struct cfg80211_pkt_pattern {
-        u8 *mask, *pattern;
+        const u8 *mask, *pattern;
         int pattern_len;
         int pkt_offset;
 };
@@ -1974,6 +2010,8 @@ struct cfg80211_update_ft_ies_params {
  * @len: buffer length
  * @no_cck: don't use cck rates for this frame
  * @dont_wait_for_ack: tells the low level not to wait for an ack
+ * @n_csa_offsets: length of csa_offsets array
+ * @csa_offsets: array of all the csa offsets in the frame
  */
 struct cfg80211_mgmt_tx_params {
         struct ieee80211_channel *chan;
@@ -1983,6 +2021,8 @@ struct cfg80211_mgmt_tx_params {
         size_t len;
         bool no_cck;
         bool dont_wait_for_ack;
+        int n_csa_offsets;
+        const u16 *csa_offsets;
 };
 
 /**
@@ -2278,6 +2318,10 @@ struct cfg80211_qos_map {
  * @channel_switch: initiate channel-switch procedure (with CSA)
  *
  * @set_qos_map: Set QoS mapping information to the driver
+ *
+ * @set_ap_chanwidth: Set the AP (including P2P GO) mode channel width for the
+ *      given interface This is used e.g. for dynamic HT 20/40 MHz channel width
+ *      changes during the lifetime of the BSS.
  */
 struct cfg80211_ops {
         int     (*suspend)(struct wiphy *wiphy, struct cfg80211_wowlan *wow);
@@ -2320,28 +2364,29 @@ struct cfg80211_ops {
 
 
         int     (*add_station)(struct wiphy *wiphy, struct net_device *dev,
-                               u8 *mac, struct station_parameters *params);
+                               const u8 *mac,
+                               struct station_parameters *params);
         int     (*del_station)(struct wiphy *wiphy, struct net_device *dev,
-                               u8 *mac);
+                               const u8 *mac);
         int     (*change_station)(struct wiphy *wiphy, struct net_device *dev,
-                                  u8 *mac, struct station_parameters *params);
+                                  const u8 *mac,
+                                  struct station_parameters *params);
         int     (*get_station)(struct wiphy *wiphy, struct net_device *dev,
-                               u8 *mac, struct station_info *sinfo);
+                               const u8 *mac, struct station_info *sinfo);
         int     (*dump_station)(struct wiphy *wiphy, struct net_device *dev,
-                               int idx, u8 *mac, struct station_info *sinfo);
+                                int idx, u8 *mac, struct station_info *sinfo);
 
         int     (*add_mpath)(struct wiphy *wiphy, struct net_device *dev,
-                               u8 *dst, u8 *next_hop);
+                               const u8 *dst, const u8 *next_hop);
         int     (*del_mpath)(struct wiphy *wiphy, struct net_device *dev,
-                               u8 *dst);
+                               const u8 *dst);
         int     (*change_mpath)(struct wiphy *wiphy, struct net_device *dev,
-                                  u8 *dst, u8 *next_hop);
+                                  const u8 *dst, const u8 *next_hop);
         int     (*get_mpath)(struct wiphy *wiphy, struct net_device *dev,
-                               u8 *dst, u8 *next_hop,
-                               struct mpath_info *pinfo);
+                             u8 *dst, u8 *next_hop, struct mpath_info *pinfo);
         int     (*dump_mpath)(struct wiphy *wiphy, struct net_device *dev,
-                               int idx, u8 *dst, u8 *next_hop,
-                               struct mpath_info *pinfo);
+                              int idx, u8 *dst, u8 *next_hop,
+                              struct mpath_info *pinfo);
         int     (*get_mesh_config)(struct wiphy *wiphy,
                                 struct net_device *dev,
                                 struct mesh_config *conf);
@@ -2471,11 +2516,11 @@ struct cfg80211_ops {
                                   struct cfg80211_gtk_rekey_data *data);
 
         int     (*tdls_mgmt)(struct wiphy *wiphy, struct net_device *dev,
-                             u8 *peer, u8 action_code,  u8 dialog_token,
+                             const u8 *peer, u8 action_code,  u8 dialog_token,
                              u16 status_code, u32 peer_capability,
                              const u8 *buf, size_t len);
         int     (*tdls_oper)(struct wiphy *wiphy, struct net_device *dev,
-                             u8 *peer, enum nl80211_tdls_operation oper);
+                             const u8 *peer, enum nl80211_tdls_operation oper);
 
         int     (*probe_client)(struct wiphy *wiphy, struct net_device *dev,
                                 const u8 *peer, u64 *cookie);
@@ -2521,9 +2566,13 @@ struct cfg80211_ops {
         int     (*channel_switch)(struct wiphy *wiphy,
                                   struct net_device *dev,
                                   struct cfg80211_csa_settings *params);
+
         int     (*set_qos_map)(struct wiphy *wiphy,
                                struct net_device *dev,
                                struct cfg80211_qos_map *qos_map);
+
+        int     (*set_ap_chanwidth)(struct wiphy *wiphy, struct net_device *dev,
+                                    struct cfg80211_chan_def *chandef);
 };
 
 /*
@@ -2618,6 +2667,7 @@ struct ieee80211_iface_limit {
  *      between infrastructure and AP types must match. This is required
  *      only in special cases.
  * @radar_detect_widths: bitmap of channel widths supported for radar detection
+ * @radar_detect_regions: bitmap of regions supported for radar detection
  *
  * With this structure the driver can describe which interface
  * combinations it supports concurrently.
@@ -2675,6 +2725,7 @@ struct ieee80211_iface_combination {
         u8 n_limits;
         bool beacon_int_infra_match;
         u8 radar_detect_widths;
+        u8 radar_detect_regions;
 };
 
 struct ieee80211_txrx_stypes {
@@ -2905,6 +2956,17 @@ struct wiphy_vendor_command {
  *      (including P2P GO) or 0 to indicate no such limit is advertised. The
  *      driver is allowed to advertise a theoretical limit that it can reach in
  *      some cases, but may not always reach.
+ *
+ * @max_num_csa_counters: Number of supported csa_counters in beacons
+ *      and probe responses.  This value should be set if the driver
+ *      wishes to limit the number of csa counters. Default (0) means
+ *      infinite.
+ * @max_adj_channel_rssi_comp: max offset of between the channel on which the
+ *      frame was sent and the channel on which the frame was heard for which
+ *      the reported rssi is still valid. If a driver is able to compensate the
+ *      low rssi when a frame is heard on different channel, then it should set
+ *      this variable to the maximal offset for which it can compensate.
+ *      This value should be set in MHz.
  */
 struct wiphy {
         /* assign these fields before you register the wiphy */
@@ -3022,6 +3084,9 @@ struct wiphy {
 
         u16 max_ap_assoc_sta;
 
+        u8 max_num_csa_counters;
+        u8 max_adj_channel_rssi_comp;
+
         char priv[0] __aligned(NETDEV_ALIGN);
 };
 
@@ -3194,6 +3259,7 @@ struct cfg80211_cached_keys;
  * @ibss_dfs_possible: (private) IBSS may change to a DFS channel
  * @event_list: (private) list for internal event processing
  * @event_lock: (private) lock for event list
+ * @owner_nlportid: (private) owner socket port ID
  */
 struct wireless_dev {
         struct wiphy *wiphy;
@@ -3241,13 +3307,15 @@ struct wireless_dev {
         unsigned long cac_start_time;
         unsigned int cac_time_ms;
 
+        u32 owner_nlportid;
+
 #ifdef CONFIG_CFG80211_WEXT
         /* wext data */
         struct {
                 struct cfg80211_ibss_params ibss;
                 struct cfg80211_connect_params connect;
                 struct cfg80211_cached_keys *keys;
-                u8 *ie;
+                const u8 *ie;
                 size_t ie_len;
                 u8 bssid[ETH_ALEN], prev_bssid[ETH_ALEN];
                 u8 ssid[IEEE80211_MAX_SSID_LEN];
@@ -3488,7 +3556,8 @@ int ieee80211_data_to_8023(struct sk_buff *skb, const u8 *addr,
  * Return: 0 on success, or a negative error code.
  */
 int ieee80211_data_from_8023(struct sk_buff *skb, const u8 *addr,
-                             enum nl80211_iftype iftype, u8 *bssid, bool qos);
+                             enum nl80211_iftype iftype, const u8 *bssid,
+                             bool qos);
 
 /**
  * ieee80211_amsdu_to_8023s - decode an IEEE 802.11n A-MSDU frame
@@ -3600,7 +3669,7 @@ int regulatory_hint(struct wiphy *wiphy, const char *alpha2);
  * default channel settings will be disregarded. If no rule is found for a
  * channel on the regulatory domain the channel will be disabled.
  * Drivers using this for a wiphy should also set the wiphy flag
- * WIPHY_FLAG_CUSTOM_REGULATORY or cfg80211 will set it for the wiphy
+ * REGULATORY_CUSTOM_REG or cfg80211 will set it for the wiphy
  * that called this helper.
  */
 void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
@@ -4289,7 +4358,7 @@ void cfg80211_roamed_bss(struct net_device *dev, struct cfg80211_bss *bss,
  * and not try to connect to any AP any more.
  */
 void cfg80211_disconnected(struct net_device *dev, u16 reason,
-                           u8 *ie, size_t ie_len, gfp_t gfp);
+                           const u8 *ie, size_t ie_len, gfp_t gfp);
 
 /**
  * cfg80211_ready_on_channel - notification of remain_on_channel start
@@ -4543,12 +4612,14 @@ void cfg80211_report_obss_beacon(struct wiphy *wiphy,
  * cfg80211_reg_can_beacon - check if beaconing is allowed
  * @wiphy: the wiphy
  * @chandef: the channel definition
+ * @iftype: interface type
  *
  * Return: %true if there is no secondary channel or the secondary channel(s)
  * can be used for beaconing (i.e. is not a radar channel etc.)
  */
 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
-                             struct cfg80211_chan_def *chandef);
+                             struct cfg80211_chan_def *chandef,
+                             enum nl80211_iftype iftype);
 
 /*
  * cfg80211_ch_switch_notify - update wdev channel and notify userspace
@@ -4694,6 +4765,84 @@ void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp);
  */
 unsigned int ieee80211_get_num_supported_channels(struct wiphy *wiphy);
 
+/**
+ * cfg80211_check_combinations - check interface combinations
+ *
+ * @wiphy: the wiphy
+ * @num_different_channels: the number of different channels we want
+ *      to use for verification
+ * @radar_detect: a bitmap where each bit corresponds to a channel
+ *      width where radar detection is needed, as in the definition of
+ *      &struct ieee80211_iface_combination.@radar_detect_widths
+ * @iftype_num: array with the numbers of interfaces of each interface
+ *      type.  The index is the interface type as specified in &enum
+ *      nl80211_iftype.
+ *
+ * This function can be called by the driver to check whether a
+ * combination of interfaces and their types are allowed according to
+ * the interface combinations.
+ */
+int cfg80211_check_combinations(struct wiphy *wiphy,
+                                const int num_different_channels,
+                                const u8 radar_detect,
+                                const int iftype_num[NUM_NL80211_IFTYPES]);
+
+/**
+ * cfg80211_iter_combinations - iterate over matching combinations
+ *
+ * @wiphy: the wiphy
+ * @num_different_channels: the number of different channels we want
+ *      to use for verification
+ * @radar_detect: a bitmap where each bit corresponds to a channel
+ *      width where radar detection is needed, as in the definition of
+ *      &struct ieee80211_iface_combination.@radar_detect_widths
+ * @iftype_num: array with the numbers of interfaces of each interface
+ *      type.  The index is the interface type as specified in &enum
+ *      nl80211_iftype.
+ * @iter: function to call for each matching combination
+ * @data: pointer to pass to iter function
+ *
+ * This function can be called by the driver to check what possible
+ * combinations it fits in at a given moment, e.g. for channel switching
+ * purposes.
+ */
+int cfg80211_iter_combinations(struct wiphy *wiphy,
+                               const int num_different_channels,
+                               const u8 radar_detect,
+                               const int iftype_num[NUM_NL80211_IFTYPES],
+                               void (*iter)(const struct ieee80211_iface_combination *c,
+                                            void *data),
+                               void *data);
+
+/*
+ * cfg80211_stop_iface - trigger interface disconnection
+ *
+ * @wiphy: the wiphy
+ * @wdev: wireless device
+ * @gfp: context flags
+ *
+ * Trigger interface to be stopped as if AP was stopped, IBSS/mesh left, STA
+ * disconnected.
+ *
+ * Note: This doesn't need any locks and is asynchronous.
+ */
+void cfg80211_stop_iface(struct wiphy *wiphy, struct wireless_dev *wdev,
+                         gfp_t gfp);
+
+/**
+ * cfg80211_shutdown_all_interfaces - shut down all interfaces for a wiphy
+ * @wiphy: the wiphy to shut down
+ *
+ * This function shuts down all interfaces belonging to this wiphy by
+ * calling dev_close() (and treating non-netdev interfaces as needed).
+ * It shouldn't really be used unless there are some fatal device errors
+ * that really can't be recovered in any other way.
+ *
+ * Callers must hold the RTNL and be able to deal with callbacks into
+ * the driver while the function is running.
+ */
+void cfg80211_shutdown_all_interfaces(struct wiphy *wiphy);
+
 /* Logging, debugging and troubleshooting/diagnostic helpers. */
 
 /* wiphy_printk helpers, similar to dev_printk */
diff --git a/include/net/checksum.h b/include/net/checksum.h
index a28f4e0f6251..87cb1903640d 100644
--- a/include/net/checksum.h
+++ b/include/net/checksum.h
@@ -57,12 +57,14 @@ static __inline__ __wsum csum_and_copy_to_user
 }
 #endif
 
+#ifndef HAVE_ARCH_CSUM_ADD
 static inline __wsum csum_add(__wsum csum, __wsum addend)
 {
         u32 res = (__force u32)csum;
         res += (__force u32)addend;
         return (__force __wsum)(res + (res < (__force u32)addend));
 }
+#endif
 
 static inline __wsum csum_sub(__wsum csum, __wsum addend)
 {
diff --git a/include/net/dsa.h b/include/net/dsa.h
index 7828ebf99ee1..6efce384451e 100644
--- a/include/net/dsa.h
+++ b/include/net/dsa.h
@@ -181,6 +181,11 @@ struct dsa_switch_driver {
 void register_switch_driver(struct dsa_switch_driver *type);
 void unregister_switch_driver(struct dsa_switch_driver *type);
 
+static inline void *ds_to_priv(struct dsa_switch *ds)
+{
+        return (void *)(ds + 1);
+}
+
 /*
  * The original DSA tag format and some other tag formats have no
  * ethertype, which means that we need to add a little hack to the
diff --git a/include/net/gre.h b/include/net/gre.h
index 70046a0b0b89..b53182018743 100644
--- a/include/net/gre.h
+++ b/include/net/gre.h
@@ -37,9 +37,10 @@ void gre_build_header(struct sk_buff *skb, const struct tnl_ptk_info *tpi,
                       int hdr_len);
 
 static inline struct sk_buff *gre_handle_offloads(struct sk_buff *skb,
-                                                  bool gre_csum)
+                                                  bool csum)
 {
-        return iptunnel_handle_offloads(skb, gre_csum, SKB_GSO_GRE);
+        return iptunnel_handle_offloads(skb, csum,
+                                        csum ? SKB_GSO_GRE_CSUM : SKB_GSO_GRE);
 }
 
 
diff --git a/include/net/ieee802154.h b/include/net/ieee802154.h
index c7ae0ac528dc..0aa7122e8f15 100644
--- a/include/net/ieee802154.h
+++ b/include/net/ieee802154.h
@@ -79,6 +79,15 @@
 #define IEEE802154_SCF_KEY_SHORT_INDEX          2
 #define IEEE802154_SCF_KEY_HW_INDEX             3
 
+#define IEEE802154_SCF_SECLEVEL_NONE            0
+#define IEEE802154_SCF_SECLEVEL_MIC32           1
+#define IEEE802154_SCF_SECLEVEL_MIC64           2
+#define IEEE802154_SCF_SECLEVEL_MIC128          3
+#define IEEE802154_SCF_SECLEVEL_ENC             4
+#define IEEE802154_SCF_SECLEVEL_ENC_MIC32       5
+#define IEEE802154_SCF_SECLEVEL_ENC_MIC64       6
+#define IEEE802154_SCF_SECLEVEL_ENC_MIC128      7
+
 /* MAC footer size */
 #define IEEE802154_MFR_SIZE     2 /* 2 octets */
 
diff --git a/include/net/ieee802154_netdev.h b/include/net/ieee802154_netdev.h
index 5a719ca892f4..3b53c8e405e4 100644
--- a/include/net/ieee802154_netdev.h
+++ b/include/net/ieee802154_netdev.h
@@ -27,6 +27,7 @@
 #ifndef IEEE802154_NETDEVICE_H
 #define IEEE802154_NETDEVICE_H
 
+#include <net/ieee802154.h>
 #include <net/af_ieee802154.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>
@@ -114,6 +115,34 @@ int ieee802154_hdr_pull(struct sk_buff *skb, struct ieee802154_hdr *hdr);
 int ieee802154_hdr_peek_addrs(const struct sk_buff *skb,
                               struct ieee802154_hdr *hdr);
 
+/* parses the full 802.15.4 header a given skb and stores them into hdr,
+ * performing pan id decompression and length checks to be suitable for use in
+ * header_ops.parse
+ */
+int ieee802154_hdr_peek(const struct sk_buff *skb, struct ieee802154_hdr *hdr);
+
+int ieee802154_max_payload(const struct ieee802154_hdr *hdr);
+
+static inline int
+ieee802154_sechdr_authtag_len(const struct ieee802154_sechdr *sec)
+{
+        switch (sec->level) {
+        case IEEE802154_SCF_SECLEVEL_MIC32:
+        case IEEE802154_SCF_SECLEVEL_ENC_MIC32:
+                return 4;
+        case IEEE802154_SCF_SECLEVEL_MIC64:
+        case IEEE802154_SCF_SECLEVEL_ENC_MIC64:
+                return 8;
+        case IEEE802154_SCF_SECLEVEL_MIC128:
+        case IEEE802154_SCF_SECLEVEL_ENC_MIC128:
+                return 16;
+        case IEEE802154_SCF_SECLEVEL_NONE:
+        case IEEE802154_SCF_SECLEVEL_ENC:
+        default:
+                return 0;
+        }
+}
+
 static inline int ieee802154_hdr_length(struct sk_buff *skb)
 {
         struct ieee802154_hdr hdr;
@@ -193,8 +222,12 @@ static inline void ieee802154_addr_to_sa(struct ieee802154_addr_sa *sa,
  */
 struct ieee802154_mac_cb {
         u8 lqi;
-        u8 flags;
-        u8 seq;
+        u8 type;
+        bool ackreq;
+        bool secen;
+        bool secen_override;
+        u8 seclevel;
+        bool seclevel_override;
         struct ieee802154_addr source;
         struct ieee802154_addr dest;
 };
@@ -204,25 +237,96 @@ static inline struct ieee802154_mac_cb *mac_cb(struct sk_buff *skb)
         return (struct ieee802154_mac_cb *)skb->cb;
 }
 
-#define MAC_CB_FLAG_TYPEMASK            ((1 << 3) - 1)
-
-#define MAC_CB_FLAG_ACKREQ              (1 << 3)
-#define MAC_CB_FLAG_SECEN               (1 << 4)
-
-static inline bool mac_cb_is_ackreq(struct sk_buff *skb)
+static inline struct ieee802154_mac_cb *mac_cb_init(struct sk_buff *skb)
 {
-        return mac_cb(skb)->flags & MAC_CB_FLAG_ACKREQ;
-}
+        BUILD_BUG_ON(sizeof(struct ieee802154_mac_cb) > sizeof(skb->cb));
 
-static inline bool mac_cb_is_secen(struct sk_buff *skb)
-{
-        return mac_cb(skb)->flags & MAC_CB_FLAG_SECEN;
+        memset(skb->cb, 0, sizeof(struct ieee802154_mac_cb));
+        return mac_cb(skb);
 }
 
-static inline int mac_cb_type(struct sk_buff *skb)
-{
-        return mac_cb(skb)->flags & MAC_CB_FLAG_TYPEMASK;
-}
+#define IEEE802154_LLSEC_KEY_SIZE 16
+
+struct ieee802154_llsec_key_id {
+        u8 mode;
+        u8 id;
+        union {
+                struct ieee802154_addr device_addr;
+                __le32 short_source;
+                __le64 extended_source;
+        };
+};
+
+struct ieee802154_llsec_key {
+        u8 frame_types;
+        u32 cmd_frame_ids;
+        u8 key[IEEE802154_LLSEC_KEY_SIZE];
+};
+
+struct ieee802154_llsec_key_entry {
+        struct list_head list;
+
+        struct ieee802154_llsec_key_id id;
+        struct ieee802154_llsec_key *key;
+};
+
+struct ieee802154_llsec_device_key {
+        struct list_head list;
+
+        struct ieee802154_llsec_key_id key_id;
+        u32 frame_counter;
+};
+
+enum {
+        IEEE802154_LLSEC_DEVKEY_IGNORE,
+        IEEE802154_LLSEC_DEVKEY_RESTRICT,
+        IEEE802154_LLSEC_DEVKEY_RECORD,
+
+        __IEEE802154_LLSEC_DEVKEY_MAX,
+};
+
+struct ieee802154_llsec_device {
+        struct list_head list;
+
+        __le16 pan_id;
+        __le16 short_addr;
+        __le64 hwaddr;
+        u32 frame_counter;
+        bool seclevel_exempt;
+
+        u8 key_mode;
+        struct list_head keys;
+};
+
+struct ieee802154_llsec_seclevel {
+        struct list_head list;
+
+        u8 frame_type;
+        u8 cmd_frame_id;
+        bool device_override;
+        u32 sec_levels;
+};
+
+struct ieee802154_llsec_params {
+        bool enabled;
+
+        __be32 frame_counter;
+        u8 out_level;
+        struct ieee802154_llsec_key_id out_key;
+
+        __le64 default_key_source;
+
+        __le16 pan_id;
+        __le64 hwaddr;
+        __le64 coord_hwaddr;
+        __le16 coord_shortaddr;
+};
+
+struct ieee802154_llsec_table {
+        struct list_head keys;
+        struct list_head devices;
+        struct list_head security_levels;
+};
 
 #define IEEE802154_MAC_SCAN_ED          0
 #define IEEE802154_MAC_SCAN_ACTIVE      1
@@ -242,6 +346,53 @@ struct ieee802154_mac_params {
 };
 
 struct wpan_phy;
+
+enum {
+        IEEE802154_LLSEC_PARAM_ENABLED = 1 << 0,
+        IEEE802154_LLSEC_PARAM_FRAME_COUNTER = 1 << 1,
+        IEEE802154_LLSEC_PARAM_OUT_LEVEL = 1 << 2,
+        IEEE802154_LLSEC_PARAM_OUT_KEY = 1 << 3,
+        IEEE802154_LLSEC_PARAM_KEY_SOURCE = 1 << 4,
+        IEEE802154_LLSEC_PARAM_PAN_ID = 1 << 5,
+        IEEE802154_LLSEC_PARAM_HWADDR = 1 << 6,
+        IEEE802154_LLSEC_PARAM_COORD_HWADDR = 1 << 7,
+        IEEE802154_LLSEC_PARAM_COORD_SHORTADDR = 1 << 8,
+};
+
+struct ieee802154_llsec_ops {
+        int (*get_params)(struct net_device *dev,
+                          struct ieee802154_llsec_params *params);
+        int (*set_params)(struct net_device *dev,
+                          const struct ieee802154_llsec_params *params,
+                          int changed);
+
+        int (*add_key)(struct net_device *dev,
+                       const struct ieee802154_llsec_key_id *id,
+                       const struct ieee802154_llsec_key *key);
+        int (*del_key)(struct net_device *dev,
+                       const struct ieee802154_llsec_key_id *id);
+
+        int (*add_dev)(struct net_device *dev,
+                       const struct ieee802154_llsec_device *llsec_dev);
+        int (*del_dev)(struct net_device *dev, __le64 dev_addr);
+
+        int (*add_devkey)(struct net_device *dev,
+                          __le64 device_addr,
+                          const struct ieee802154_llsec_device_key *key);
+        int (*del_devkey)(struct net_device *dev,
+                          __le64 device_addr,
+                          const struct ieee802154_llsec_device_key *key);
+
+        int (*add_seclevel)(struct net_device *dev,
+                            const struct ieee802154_llsec_seclevel *sl);
+        int (*del_seclevel)(struct net_device *dev,
+                            const struct ieee802154_llsec_seclevel *sl);
+
+        void (*lock_table)(struct net_device *dev);
+        void (*get_table)(struct net_device *dev,
+                          struct ieee802154_llsec_table **t);
+        void (*unlock_table)(struct net_device *dev);
+};
 /*
  * This should be located at net_device->ml_priv
  *
@@ -272,6 +423,8 @@ struct ieee802154_mlme_ops {
         void (*get_mac_params)(struct net_device *dev,
                                struct ieee802154_mac_params *params);
 
+        struct ieee802154_llsec_ops *llsec;
+
         /* The fields below are required. */
 
         struct wpan_phy *(*get_phy)(const struct net_device *dev);
diff --git a/include/net/inet_ecn.h b/include/net/inet_ecn.h
index 3bd22795c3e2..84b20835b736 100644
--- a/include/net/inet_ecn.h
+++ b/include/net/inet_ecn.h
@@ -150,7 +150,7 @@ static inline int INET_ECN_set_ce(struct sk_buff *skb)
 }
 
 /*
- * RFC 6080 4.2
+ * RFC 6040 4.2
  *  To decapsulate the inner header at the tunnel egress, a compliant
  *  tunnel egress MUST set the outgoing ECN field to the codepoint at the
  *  intersection of the appropriate arriving inner header (row) and outer
diff --git a/include/net/inet_hashtables.h b/include/net/inet_hashtables.h
index 1bdb47715def..dd1950a7e273 100644
--- a/include/net/inet_hashtables.h
+++ b/include/net/inet_hashtables.h
@@ -292,12 +292,12 @@ static inline struct sock *inet_lookup_listener(struct net *net,
 #define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
         const __addrpair __name = (__force __addrpair) ( \
                                    (((__force __u64)(__be32)(__saddr)) << 32) | \
-                                   ((__force __u64)(__be32)(__daddr)));
+                                   ((__force __u64)(__be32)(__daddr)))
 #else /* __LITTLE_ENDIAN */
 #define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
         const __addrpair __name = (__force __addrpair) ( \
                                    (((__force __u64)(__be32)(__daddr)) << 32) | \
-                                   ((__force __u64)(__be32)(__saddr)));
+                                   ((__force __u64)(__be32)(__saddr)))
 #endif /* __BIG_ENDIAN */
 #define INET_MATCH(__sk, __net, __cookie, __saddr, __daddr, __ports, __dif)     \
         (((__sk)->sk_portpair == (__ports))                     &&      \
@@ -306,7 +306,9 @@ static inline struct sock *inet_lookup_listener(struct net *net,
            ((__sk)->sk_bound_dev_if == (__dif)))                &&      \
          net_eq(sock_net(__sk), (__net)))
 #else /* 32-bit arch */
-#define INET_ADDR_COOKIE(__name, __saddr, __daddr)
+#define INET_ADDR_COOKIE(__name, __saddr, __daddr) \
+        const int __name __deprecated __attribute__((unused))
+
 #define INET_MATCH(__sk, __net, __cookie, __saddr, __daddr, __ports, __dif) \
         (((__sk)->sk_portpair == (__ports))             &&              \
          ((__sk)->sk_daddr      == (__saddr))           &&              \
diff --git a/include/net/inet_sock.h b/include/net/inet_sock.h
index 1833c3f389ee..b1edf17bec01 100644
--- a/include/net/inet_sock.h
+++ b/include/net/inet_sock.h
@@ -90,6 +90,7 @@ struct inet_request_sock {
         kmemcheck_bitfield_end(flags);
         struct ip_options_rcu   *opt;
         struct sk_buff          *pktopts;
+        u32                     ir_mark;
 };
 
 static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
@@ -97,6 +98,15 @@ static inline struct inet_request_sock *inet_rsk(const struct request_sock *sk)
         return (struct inet_request_sock *)sk;
 }
 
+static inline u32 inet_request_mark(struct sock *sk, struct sk_buff *skb)
+{
+        if (!sk->sk_mark && sock_net(sk)->ipv4.sysctl_tcp_fwmark_accept) {
+                return skb->mark;
+        } else {
+                return sk->sk_mark;
+        }
+}
+
 struct inet_cork {
         unsigned int            flags;
         __be32                  addr;
diff --git a/include/net/inetpeer.h b/include/net/inetpeer.h
index 058271bde27a..01d590ee5e7e 100644
--- a/include/net/inetpeer.h
+++ b/include/net/inetpeer.h
@@ -41,14 +41,13 @@ struct inet_peer {
                 struct rcu_head     gc_rcu;
         };
         /*
-         * Once inet_peer is queued for deletion (refcnt == -1), following fields
-         * are not available: rid, ip_id_count
+         * Once inet_peer is queued for deletion (refcnt == -1), following field
+         * is not available: rid
          * We can share memory with rcu_head to help keep inet_peer small.
          */
         union {
                 struct {
                         atomic_t                        rid;            /* Frag reception counter */
-                        atomic_t                        ip_id_count;    /* IP ID for the next packet */
                 };
                 struct rcu_head         rcu;
                 struct inet_peer        *gc_next;
@@ -165,21 +164,11 @@ bool inet_peer_xrlim_allow(struct inet_peer *peer, int timeout);
 void inetpeer_invalidate_tree(struct inet_peer_base *);
 
 /*
- * temporary check to make sure we dont access rid, ip_id_count, tcp_ts,
+ * temporary check to make sure we dont access rid, tcp_ts,
  * tcp_ts_stamp if no refcount is taken on inet_peer
  */
 static inline void inet_peer_refcheck(const struct inet_peer *p)
 {
         WARN_ON_ONCE(atomic_read(&p->refcnt) <= 0);
 }
-
-
-/* can be called with or without local BH being disabled */
-static inline int inet_getid(struct inet_peer *p, int more)
-{
-        more++;
-        inet_peer_refcheck(p);
-        return atomic_add_return(more, &p->ip_id_count) - more;
-}
-
 #endif /* _NET_INETPEER_H */
diff --git a/include/net/ip.h b/include/net/ip.h
index 3ec2b0fb9d83..0e795df05ec9 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -196,35 +196,31 @@ void ip_send_unicast_reply(struct net *net, struct sk_buff *skb, __be32 daddr,
 #define NET_ADD_STATS_BH(net, field, adnd) SNMP_ADD_STATS_BH((net)->mib.net_statistics, field, adnd)
 #define NET_ADD_STATS_USER(net, field, adnd) SNMP_ADD_STATS_USER((net)->mib.net_statistics, field, adnd)
 
-unsigned long snmp_fold_field(void __percpu *mib[], int offt);
+unsigned long snmp_fold_field(void __percpu *mib, int offt);
 #if BITS_PER_LONG==32
-u64 snmp_fold_field64(void __percpu *mib[], int offt, size_t sync_off);
+u64 snmp_fold_field64(void __percpu *mib, int offt, size_t sync_off);
 #else
-static inline u64 snmp_fold_field64(void __percpu *mib[], int offt, size_t syncp_off)
+static inline u64 snmp_fold_field64(void __percpu *mib, int offt, size_t syncp_off)
 {
         return snmp_fold_field(mib, offt);
 }
 #endif
-int snmp_mib_init(void __percpu *ptr[2], size_t mibsize, size_t align);
-
-static inline void snmp_mib_free(void __percpu *ptr[SNMP_ARRAY_SZ])
-{
-        int i;
-
-        BUG_ON(ptr == NULL);
-        for (i = 0; i < SNMP_ARRAY_SZ; i++) {
-                free_percpu(ptr[i]);
-                ptr[i] = NULL;
-        }
-}
 
 void inet_get_local_port_range(struct net *net, int *low, int *high);
 
-extern unsigned long *sysctl_local_reserved_ports;
-static inline int inet_is_reserved_local_port(int port)
+#ifdef CONFIG_SYSCTL
+static inline int inet_is_local_reserved_port(struct net *net, int port)
 {
-        return test_bit(port, sysctl_local_reserved_ports);
+        if (!net->ipv4.sysctl_local_reserved_ports)
+                return 0;
+        return test_bit(port, net->ipv4.sysctl_local_reserved_ports);
 }
+#else
+static inline int inet_is_local_reserved_port(struct net *net, int port)
+{
+        return 0;
+}
+#endif
 
 extern int sysctl_ip_nonlocal_bind;
 
@@ -243,6 +239,9 @@ void ipfrag_init(void);
 
 void ip_static_sysctl_init(void);
 
+#define IP4_REPLY_MARK(net, mark) \
+        ((net)->ipv4.sysctl_fwmark_reflect ? (mark) : 0)
+
 static inline bool ip_is_fragment(const struct iphdr *iph)
 {
         return (iph->frag_off & htons(IP_MF | IP_OFFSET)) != 0;
@@ -281,7 +280,7 @@ static inline bool ip_sk_use_pmtu(const struct sock *sk)
         return inet_sk(sk)->pmtudisc < IP_PMTUDISC_PROBE;
 }
 
-static inline bool ip_sk_local_df(const struct sock *sk)
+static inline bool ip_sk_ignore_df(const struct sock *sk)
 {
         return inet_sk(sk)->pmtudisc < IP_PMTUDISC_DO ||
                inet_sk(sk)->pmtudisc == IP_PMTUDISC_OMIT;
@@ -310,36 +309,48 @@ static inline unsigned int ip_skb_dst_mtu(const struct sk_buff *skb)
         }
 }
 
-void __ip_select_ident(struct iphdr *iph, struct dst_entry *dst, int more);
+#define IP_IDENTS_SZ 2048u
+extern atomic_t *ip_idents;
+
+static inline u32 ip_idents_reserve(u32 hash, int segs)
+{
+        atomic_t *id_ptr = ip_idents + hash % IP_IDENTS_SZ;
+
+        return atomic_add_return(segs, id_ptr) - segs;
+}
+
+void __ip_select_ident(struct iphdr *iph, int segs);
 
-static inline void ip_select_ident(struct sk_buff *skb, struct dst_entry *dst, struct sock *sk)
+static inline void ip_select_ident_segs(struct sk_buff *skb, struct sock *sk, int segs)
 {
         struct iphdr *iph = ip_hdr(skb);
 
-        if ((iph->frag_off & htons(IP_DF)) && !skb->local_df) {
+        if ((iph->frag_off & htons(IP_DF)) && !skb->ignore_df) {
                 /* This is only to work around buggy Windows95/2000
                  * VJ compression implementations.  If the ID field
                  * does not change, they drop every other packet in
                  * a TCP stream using header compression.
                  */
-                iph->id = (sk && inet_sk(sk)->inet_daddr) ?
-                                        htons(inet_sk(sk)->inet_id++) : 0;
-        } else
-                __ip_select_ident(iph, dst, 0);
+                if (sk && inet_sk(sk)->inet_daddr) {
+                        iph->id = htons(inet_sk(sk)->inet_id);
+                        inet_sk(sk)->inet_id += segs;
+                } else {
+                        iph->id = 0;
+                }
+        } else {
+                __ip_select_ident(iph, segs);
+        }
 }
 
-static inline void ip_select_ident_more(struct sk_buff *skb, struct dst_entry *dst, struct sock *sk, int more)
+static inline void ip_select_ident(struct sk_buff *skb, struct sock *sk)
 {
-        struct iphdr *iph = ip_hdr(skb);
+        ip_select_ident_segs(skb, sk, 1);
+}
 
-        if ((iph->frag_off & htons(IP_DF)) && !skb->local_df) {
-                if (sk && inet_sk(sk)->inet_daddr) {
-                        iph->id = htons(inet_sk(sk)->inet_id);
-                        inet_sk(sk)->inet_id += 1 + more;
-                } else
-                        iph->id = 0;
-        } else
-                __ip_select_ident(iph, dst, more);
+static inline __wsum inet_compute_pseudo(struct sk_buff *skb, int proto)
+{
+        return csum_tcpudp_nofold(ip_hdr(skb)->saddr, ip_hdr(skb)->daddr,
+                                  skb->len, proto, 0);
 }
 
 /*
diff --git a/include/net/ip6_checksum.h b/include/net/ip6_checksum.h
index 9e3c540c1b11..55236cb71174 100644
--- a/include/net/ip6_checksum.h
+++ b/include/net/ip6_checksum.h
@@ -41,6 +41,13 @@ __sum16 csum_ipv6_magic(const struct in6_addr *saddr,
                         __wsum csum);
 #endif
 
+static inline __wsum ip6_compute_pseudo(struct sk_buff *skb, int proto)
+{
+        return ~csum_unfold(csum_ipv6_magic(&ipv6_hdr(skb)->saddr,
+                                            &ipv6_hdr(skb)->daddr,
+                                            skb->len, proto, 0));
+}
+
 static __inline__ __sum16 tcp_v6_check(int len,
                                    const struct in6_addr *saddr,
                                    const struct in6_addr *daddr,
@@ -75,5 +82,17 @@ static inline void tcp_v6_send_check(struct sock *sk, struct sk_buff *skb)
 }
 #endif
 
+static inline __sum16 udp_v6_check(int len,
+                                   const struct in6_addr *saddr,
+                                   const struct in6_addr *daddr,
+                                   __wsum base)
+{
+        return csum_ipv6_magic(saddr, daddr, len, IPPROTO_UDP, base);
+}
+
+void udp6_set_csum(bool nocheck, struct sk_buff *skb,
+                   const struct in6_addr *saddr,
+                   const struct in6_addr *daddr, int len);
+
 int udp6_csum_init(struct sk_buff *skb, struct udphdr *uh, int proto);
 #endif
diff --git a/include/net/ip6_route.h b/include/net/ip6_route.h
index 216cecce65e9..1d09b46c1e48 100644
--- a/include/net/ip6_route.h
+++ b/include/net/ip6_route.h
@@ -186,7 +186,7 @@ static inline bool ip6_sk_accept_pmtu(const struct sock *sk)
                inet6_sk(sk)->pmtudisc != IPV6_PMTUDISC_OMIT;
 }
 
-static inline bool ip6_sk_local_df(const struct sock *sk)
+static inline bool ip6_sk_ignore_df(const struct sock *sk)
 {
         return inet6_sk(sk)->pmtudisc < IPV6_PMTUDISC_DO ||
                inet6_sk(sk)->pmtudisc == IPV6_PMTUDISC_OMIT;
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index d640925bc454..574337fe72dd 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -113,6 +113,9 @@ struct frag_hdr {
 #define IP6_MF          0x0001
 #define IP6_OFFSET      0xFFF8
 
+#define IP6_REPLY_MARK(net, mark) \
+        ((net)->ipv6.sysctl.fwmark_reflect ? (mark) : 0)
+
 #include <net/sock.h>
 
 /* sysctls */
@@ -583,6 +586,11 @@ static inline bool ipv6_addr_orchid(const struct in6_addr *a)
         return (a->s6_addr32[0] & htonl(0xfffffff0)) == htonl(0x20010010);
 }
 
+static inline bool ipv6_addr_is_multicast(const struct in6_addr *addr)
+{
+        return (addr->s6_addr32[0] & htonl(0xFF000000)) == htonl(0xFF000000);
+}
+
 static inline void ipv6_addr_set_v4mapped(const __be32 addr,
                                           struct in6_addr *v4mapped)
 {
@@ -660,10 +668,22 @@ static inline int ipv6_addr_diff(const struct in6_addr *a1, const struct in6_add
         return __ipv6_addr_diff(a1, a2, sizeof(struct in6_addr));
 }
 
-void ipv6_select_ident(struct frag_hdr *fhdr, struct rt6_info *rt);
-
 int ip6_dst_hoplimit(struct dst_entry *dst);
 
+static inline int ip6_sk_dst_hoplimit(struct ipv6_pinfo *np, struct flowi6 *fl6,
+                                      struct dst_entry *dst)
+{
+        int hlimit;
+
+        if (ipv6_addr_is_multicast(&fl6->daddr))
+                hlimit = np->mcast_hops;
+        else
+                hlimit = np->hop_limit;
+        if (hlimit < 0)
+                hlimit = ip6_dst_hoplimit(dst);
+        return hlimit;
+}
+
 /*
  *      Header manipulation
  */
diff --git a/include/net/mac80211.h b/include/net/mac80211.h
index 8248e3909fdf..421b6ecb4b2c 100644
--- a/include/net/mac80211.h
+++ b/include/net/mac80211.h
@@ -189,6 +189,43 @@ struct ieee80211_chanctx_conf {
 };
 
 /**
+ * enum ieee80211_chanctx_switch_mode - channel context switch mode
+ * @CHANCTX_SWMODE_REASSIGN_VIF: Both old and new contexts already
+ *      exist (and will continue to exist), but the virtual interface
+ *      needs to be switched from one to the other.
+ * @CHANCTX_SWMODE_SWAP_CONTEXTS: The old context exists but will stop
+ *      to exist with this call, the new context doesn't exist but
+ *      will be active after this call, the virtual interface switches
+ *      from the old to the new (note that the driver may of course
+ *      implement this as an on-the-fly chandef switch of the existing
+ *      hardware context, but the mac80211 pointer for the old context
+ *      will cease to exist and only the new one will later be used
+ *      for changes/removal.)
+ */
+enum ieee80211_chanctx_switch_mode {
+        CHANCTX_SWMODE_REASSIGN_VIF,
+        CHANCTX_SWMODE_SWAP_CONTEXTS,
+};
+
+/**
+ * struct ieee80211_vif_chanctx_switch - vif chanctx switch information
+ *
+ * This is structure is used to pass information about a vif that
+ * needs to switch from one chanctx to another.  The
+ * &ieee80211_chanctx_switch_mode defines how the switch should be
+ * done.
+ *
+ * @vif: the vif that should be switched from old_ctx to new_ctx
+ * @old_ctx: the old context to which the vif was assigned
+ * @new_ctx: the new context to which the vif must be assigned
+ */
+struct ieee80211_vif_chanctx_switch {
+        struct ieee80211_vif *vif;
+        struct ieee80211_chanctx_conf *old_ctx;
+        struct ieee80211_chanctx_conf *new_ctx;
+};
+
+/**
  * enum ieee80211_bss_change - BSS change notification flags
  *
  * These flags are used with the bss_info_changed() callback
@@ -1113,7 +1150,9 @@ enum ieee80211_vif_flags {
  * @addr: address of this interface
  * @p2p: indicates whether this AP or STA interface is a p2p
  *      interface, i.e. a GO or p2p-sta respectively
- * @csa_active: marks whether a channel switch is going on
+ * @csa_active: marks whether a channel switch is going on. Internally it is
+ *      write-protected by sdata_lock and local->mtx so holding either is fine
+ *      for read access.
  * @driver_flags: flags/capabilities the driver has for this interface,
  *      these need to be set (or cleared) when the interface is added
  *      or, if supported by the driver, the interface type is changed
@@ -1202,14 +1241,18 @@ struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev);
  *      fall back to software crypto. Note that this flag deals only with
  *      RX, if your crypto engine can't deal with TX you can also set the
  *      %IEEE80211_KEY_FLAG_SW_MGMT_TX flag to encrypt such frames in SW.
+ * @IEEE80211_KEY_FLAG_GENERATE_IV_MGMT: This flag should be set by the
+ *      driver for a CCMP key to indicate that is requires IV generation
+ *      only for managment frames (MFP).
  */
 enum ieee80211_key_flags {
-        IEEE80211_KEY_FLAG_GENERATE_IV  = 1<<1,
-        IEEE80211_KEY_FLAG_GENERATE_MMIC= 1<<2,
-        IEEE80211_KEY_FLAG_PAIRWISE     = 1<<3,
-        IEEE80211_KEY_FLAG_SW_MGMT_TX   = 1<<4,
-        IEEE80211_KEY_FLAG_PUT_IV_SPACE = 1<<5,
-        IEEE80211_KEY_FLAG_RX_MGMT      = 1<<6,
+        IEEE80211_KEY_FLAG_GENERATE_IV_MGMT     = BIT(0),
+        IEEE80211_KEY_FLAG_GENERATE_IV          = BIT(1),
+        IEEE80211_KEY_FLAG_GENERATE_MMIC        = BIT(2),
+        IEEE80211_KEY_FLAG_PAIRWISE             = BIT(3),
+        IEEE80211_KEY_FLAG_SW_MGMT_TX           = BIT(4),
+        IEEE80211_KEY_FLAG_PUT_IV_SPACE         = BIT(5),
+        IEEE80211_KEY_FLAG_RX_MGMT              = BIT(6),
 };
 
 /**
@@ -1370,6 +1413,7 @@ struct ieee80211_sta_rates {
  *      the station moves to associated state.
  * @smps_mode: current SMPS mode (off, static or dynamic)
  * @rates: rate control selection table
+ * @tdls: indicates whether the STA is a TDLS peer
  */
 struct ieee80211_sta {
         u32 supp_rates[IEEE80211_NUM_BANDS];
@@ -1384,6 +1428,7 @@ struct ieee80211_sta {
         enum ieee80211_sta_rx_bandwidth bandwidth;
         enum ieee80211_smps_mode smps_mode;
         struct ieee80211_sta_rates __rcu *rates;
+        bool tdls;
 
         /* must be last */
         u8 drv_priv[0] __aligned(sizeof(void *));
@@ -1555,6 +1600,12 @@ struct ieee80211_tx_control {
  *      for a single active channel while using channel contexts. When support
  *      is not enabled the default action is to disconnect when getting the
  *      CSA frame.
+ *
+ * @IEEE80211_HW_CHANGE_RUNNING_CHANCTX: The hardware can change a
+ *      channel context on-the-fly.  This is needed for channel switch
+ *      on single-channel hardware.  It can also be used as an
+ *      optimization in certain channel switch cases with
+ *      multi-channel.
  */
 enum ieee80211_hw_flags {
         IEEE80211_HW_HAS_RATE_CONTROL                   = 1<<0,
@@ -1586,6 +1637,7 @@ enum ieee80211_hw_flags {
         IEEE80211_HW_TIMING_BEACON_ONLY                 = 1<<26,
         IEEE80211_HW_SUPPORTS_HT_CCK_RATES              = 1<<27,
         IEEE80211_HW_CHANCTX_STA_CSA                    = 1<<28,
+        IEEE80211_HW_CHANGE_RUNNING_CHANCTX             = 1<<29,
 };
 
 /**
@@ -2609,6 +2661,7 @@ enum ieee80211_roc_type {
  *      of queues to flush, which is useful if different virtual interfaces
  *      use different hardware queues; it may also indicate all queues.
  *      If the parameter @drop is set to %true, pending frames may be dropped.
+ *      Note that vif can be NULL.
  *      The callback can sleep.
  *
  * @channel_switch: Drivers that need (or want) to offload the channel
@@ -2720,6 +2773,11 @@ enum ieee80211_roc_type {
  *      to vif. Possible use is for hw queue remapping.
  * @unassign_vif_chanctx: Notifies device driver about channel context being
  *      unbound from vif.
+ * @switch_vif_chanctx: switch a number of vifs from one chanctx to
+ *      another, as specified in the list of
+ *      @ieee80211_vif_chanctx_switch passed to the driver, according
+ *      to the mode defined in &ieee80211_chanctx_switch_mode.
+ *
  * @start_ap: Start operation on the AP interface, this is called after all the
  *      information in bss_conf is set and beacon can be retrieved. A channel
  *      context is bound before this is called. Note that if the driver uses
@@ -2753,6 +2811,10 @@ enum ieee80211_roc_type {
  *      information in bss_conf is set up and the beacon can be retrieved. A
  *      channel context is bound before this is called.
  * @leave_ibss: Leave the IBSS again.
+ *
+ * @get_expected_throughput: extract the expected throughput towards the
+ *      specified station. The returned value is expressed in Kbps. It returns 0
+ *      if the RC algorithm does not have proper data to provide.
  */
 struct ieee80211_ops {
         void (*tx)(struct ieee80211_hw *hw,
@@ -2871,7 +2933,8 @@ struct ieee80211_ops {
                              struct netlink_callback *cb,
                              void *data, int len);
 #endif
-        void (*flush)(struct ieee80211_hw *hw, u32 queues, bool drop);
+        void (*flush)(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
+                      u32 queues, bool drop);
         void (*channel_switch)(struct ieee80211_hw *hw,
                                struct ieee80211_channel_switch *ch_switch);
         int (*set_antenna)(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant);
@@ -2931,6 +2994,10 @@ struct ieee80211_ops {
         void (*unassign_vif_chanctx)(struct ieee80211_hw *hw,
                                      struct ieee80211_vif *vif,
                                      struct ieee80211_chanctx_conf *ctx);
+        int (*switch_vif_chanctx)(struct ieee80211_hw *hw,
+                                  struct ieee80211_vif_chanctx_switch *vifs,
+                                  int n_vifs,
+                                  enum ieee80211_chanctx_switch_mode mode);
 
         void (*restart_complete)(struct ieee80211_hw *hw);
 
@@ -2945,6 +3012,7 @@ struct ieee80211_ops {
 
         int (*join_ibss)(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
         void (*leave_ibss)(struct ieee80211_hw *hw, struct ieee80211_vif *vif);
+        u32 (*get_expected_throughput)(struct ieee80211_sta *sta);
 };
 
 /**
@@ -3394,6 +3462,47 @@ void ieee80211_tx_status_irqsafe(struct ieee80211_hw *hw,
  */
 void ieee80211_report_low_ack(struct ieee80211_sta *sta, u32 num_packets);
 
+#define IEEE80211_MAX_CSA_COUNTERS_NUM 2
+
+/**
+ * struct ieee80211_mutable_offsets - mutable beacon offsets
+ * @tim_offset: position of TIM element
+ * @tim_length: size of TIM element
+ * @csa_counter_offs: array of IEEE80211_MAX_CSA_COUNTERS_NUM offsets
+ *      to CSA counters.  This array can contain zero values which
+ *      should be ignored.
+ */
+struct ieee80211_mutable_offsets {
+        u16 tim_offset;
+        u16 tim_length;
+
+        u16 csa_counter_offs[IEEE80211_MAX_CSA_COUNTERS_NUM];
+};
+
+/**
+ * ieee80211_beacon_get_template - beacon template generation function
+ * @hw: pointer obtained from ieee80211_alloc_hw().
+ * @vif: &struct ieee80211_vif pointer from the add_interface callback.
+ * @offs: &struct ieee80211_mutable_offsets pointer to struct that will
+ *      receive the offsets that may be updated by the driver.
+ *
+ * If the driver implements beaconing modes, it must use this function to
+ * obtain the beacon template.
+ *
+ * This function should be used if the beacon frames are generated by the
+ * device, and then the driver must use the returned beacon as the template
+ * The driver or the device are responsible to update the DTIM and, when
+ * applicable, the CSA count.
+ *
+ * The driver is responsible for freeing the returned skb.
+ *
+ * Return: The beacon template. %NULL on error.
+ */
+struct sk_buff *
+ieee80211_beacon_get_template(struct ieee80211_hw *hw,
+                              struct ieee80211_vif *vif,
+                              struct ieee80211_mutable_offsets *offs);
+
 /**
  * ieee80211_beacon_get_tim - beacon generation function
  * @hw: pointer obtained from ieee80211_alloc_hw().
@@ -3405,16 +3514,12 @@ void ieee80211_report_low_ack(struct ieee80211_sta *sta, u32 num_packets);
  *      Set to 0 if invalid (in non-AP modes).
  *
  * If the driver implements beaconing modes, it must use this function to
- * obtain the beacon frame/template.
+ * obtain the beacon frame.
  *
  * If the beacon frames are generated by the host system (i.e., not in
  * hardware/firmware), the driver uses this function to get each beacon
- * frame from mac80211 -- it is responsible for calling this function
- * before the beacon is needed (e.g. based on hardware interrupt).
- *
- * If the beacon frames are generated by the device, then the driver
- * must use the returned beacon as the template and change the TIM IE
- * according to the current DTIM parameters/TIM bitmap.
+ * frame from mac80211 -- it is responsible for calling this function exactly
+ * once before the beacon is needed (e.g. based on hardware interrupt).
  *
  * The driver is responsible for freeing the returned skb.
  *
@@ -3440,6 +3545,20 @@ static inline struct sk_buff *ieee80211_beacon_get(struct ieee80211_hw *hw,
 }
 
 /**
+ * ieee80211_csa_update_counter - request mac80211 to decrement the csa counter
+ * @vif: &struct ieee80211_vif pointer from the add_interface callback.
+ *
+ * The csa counter should be updated after each beacon transmission.
+ * This function is called implicitly when
+ * ieee80211_beacon_get/ieee80211_beacon_get_tim are called, however if the
+ * beacon frames are generated by the device, the driver should call this
+ * function after each beacon transmission to sync mac80211's csa counters.
+ *
+ * Return: new csa counter value
+ */
+u8 ieee80211_csa_update_counter(struct ieee80211_vif *vif);
+
+/**
  * ieee80211_csa_finish - notify mac80211 about channel switch
  * @vif: &struct ieee80211_vif pointer from the add_interface callback.
  *
@@ -4467,6 +4586,8 @@ struct rate_control_ops {
         void (*add_sta_debugfs)(void *priv, void *priv_sta,
                                 struct dentry *dir);
         void (*remove_sta_debugfs)(void *priv, void *priv_sta);
+
+        u32 (*get_expected_throughput)(void *priv_sta);
 };
 
 static inline int rate_supported(struct ieee80211_sta *sta,
@@ -4576,7 +4697,9 @@ conf_is_ht40(struct ieee80211_conf *conf)
 static inline bool
 conf_is_ht(struct ieee80211_conf *conf)
 {
-        return conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT;
+        return (conf->chandef.width != NL80211_CHAN_WIDTH_5) &&
+                (conf->chandef.width != NL80211_CHAN_WIDTH_10) &&
+                (conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT);
 }
 
 static inline enum nl80211_iftype
diff --git a/include/net/net_namespace.h b/include/net/net_namespace.h
index 5f9eb260990f..361d26077196 100644
--- a/include/net/net_namespace.h
+++ b/include/net/net_namespace.h
@@ -373,6 +373,14 @@ static inline void rt_genid_bump_ipv6(struct net *net)
 }
 #endif
 
+#if IS_ENABLED(CONFIG_IEEE802154_6LOWPAN)
+static inline struct netns_ieee802154_lowpan *
+net_ieee802154_lowpan(struct net *net)
+{
+        return &net->ieee802154_lowpan;
+}
+#endif
+
 /* For callers who don't really care about whether it's IPv4 or IPv6 */
 static inline void rt_genid_bump_all(struct net *net)
 {
diff --git a/include/net/netfilter/nf_nat.h b/include/net/netfilter/nf_nat.h
index 07eaaf604092..a71dd333ac68 100644
--- a/include/net/netfilter/nf_nat.h
+++ b/include/net/netfilter/nf_nat.h
@@ -48,6 +48,8 @@ unsigned int nf_nat_setup_info(struct nf_conn *ct,
 extern unsigned int nf_nat_alloc_null_binding(struct nf_conn *ct,
                                               unsigned int hooknum);
 
+struct nf_conn_nat *nf_ct_nat_ext_add(struct nf_conn *ct);
+
 /* Is this tuple already taken? (not by us)*/
 int nf_nat_used_tuple(const struct nf_conntrack_tuple *tuple,
                       const struct nf_conn *ignored_conntrack);
diff --git a/include/net/netfilter/nf_tables.h b/include/net/netfilter/nf_tables.h
index e6bc14d8fa9a..7ee6ce6564ae 100644
--- a/include/net/netfilter/nf_tables.h
+++ b/include/net/netfilter/nf_tables.h
@@ -72,21 +72,23 @@ static inline void nft_data_debug(const struct nft_data *data)
  *      struct nft_ctx - nf_tables rule/set context
  *
  *      @net: net namespace
- *      @skb: netlink skb
- *      @nlh: netlink message header
  *      @afi: address family info
  *      @table: the table the chain is contained in
  *      @chain: the chain the rule is contained in
  *      @nla: netlink attributes
+ *      @portid: netlink portID of the original message
+ *      @seq: netlink sequence number
+ *      @report: notify via unicast netlink message
  */
 struct nft_ctx {
         struct net                      *net;
-        const struct sk_buff            *skb;
-        const struct nlmsghdr           *nlh;
-        const struct nft_af_info        *afi;
-        const struct nft_table          *table;
-        const struct nft_chain          *chain;
+        struct nft_af_info              *afi;
+        struct nft_table                *table;
+        struct nft_chain                *chain;
         const struct nlattr * const     *nla;
+        u32                             portid;
+        u32                             seq;
+        bool                            report;
 };
 
 struct nft_data_desc {
@@ -146,6 +148,44 @@ struct nft_set_iter {
 };
 
 /**
+ *      struct nft_set_desc - description of set elements
+ *
+ *      @klen: key length
+ *      @dlen: data length
+ *      @size: number of set elements
+ */
+struct nft_set_desc {
+        unsigned int            klen;
+        unsigned int            dlen;
+        unsigned int            size;
+};
+
+/**
+ *      enum nft_set_class - performance class
+ *
+ *      @NFT_LOOKUP_O_1: constant, O(1)
+ *      @NFT_LOOKUP_O_LOG_N: logarithmic, O(log N)
+ *      @NFT_LOOKUP_O_N: linear, O(N)
+ */
+enum nft_set_class {
+        NFT_SET_CLASS_O_1,
+        NFT_SET_CLASS_O_LOG_N,
+        NFT_SET_CLASS_O_N,
+};
+
+/**
+ *      struct nft_set_estimate - estimation of memory and performance
+ *                                characteristics
+ *
+ *      @size: required memory
+ *      @class: lookup performance class
+ */
+struct nft_set_estimate {
+        unsigned int            size;
+        enum nft_set_class      class;
+};
+
+/**
  *      struct nft_set_ops - nf_tables set operations
  *
  *      @lookup: look up an element within the set
@@ -174,7 +214,11 @@ struct nft_set_ops {
                                                 struct nft_set_iter *iter);
 
         unsigned int                    (*privsize)(const struct nlattr * const nla[]);
+        bool                            (*estimate)(const struct nft_set_desc *desc,
+                                                    u32 features,
+                                                    struct nft_set_estimate *est);
         int                             (*init)(const struct nft_set *set,
+                                                const struct nft_set_desc *desc,
                                                 const struct nlattr * const nla[]);
         void                            (*destroy)(const struct nft_set *set);
 
@@ -194,6 +238,8 @@ void nft_unregister_set(struct nft_set_ops *ops);
  *      @name: name of the set
  *      @ktype: key type (numeric type defined by userspace, not used in the kernel)
  *      @dtype: data type (verdict or numeric type defined by userspace)
+ *      @size: maximum set size
+ *      @nelems: number of elements
  *      @ops: set ops
  *      @flags: set flags
  *      @klen: key length
@@ -206,6 +252,8 @@ struct nft_set {
         char                            name[IFNAMSIZ];
         u32                             ktype;
         u32                             dtype;
+        u32                             size;
+        u32                             nelems;
         /* runtime data below here */
         const struct nft_set_ops        *ops ____cacheline_aligned;
         u16                             flags;
@@ -222,6 +270,8 @@ static inline void *nft_set_priv(const struct nft_set *set)
 
 struct nft_set *nf_tables_set_lookup(const struct nft_table *table,
                                      const struct nlattr *nla);
+struct nft_set *nf_tables_set_lookup_byid(const struct net *net,
+                                          const struct nlattr *nla);
 
 /**
  *      struct nft_set_binding - nf_tables set binding
@@ -341,18 +391,75 @@ struct nft_rule {
 };
 
 /**
- *      struct nft_rule_trans - nf_tables rule update in transaction
+ *      struct nft_trans - nf_tables object update in transaction
  *
+ *      @rcu_head: rcu head to defer release of transaction data
  *      @list: used internally
- *      @ctx: rule context
- *      @rule: rule that needs to be updated
+ *      @msg_type: message type
+ *      @ctx: transaction context
+ *      @data: internal information related to the transaction
  */
-struct nft_rule_trans {
+struct nft_trans {
+        struct rcu_head                 rcu_head;
         struct list_head                list;
+        int                             msg_type;
         struct nft_ctx                  ctx;
+        char                            data[0];
+};
+
+struct nft_trans_rule {
         struct nft_rule                 *rule;
 };
 
+#define nft_trans_rule(trans)   \
+        (((struct nft_trans_rule *)trans->data)->rule)
+
+struct nft_trans_set {
+        struct nft_set  *set;
+        u32             set_id;
+};
+
+#define nft_trans_set(trans)    \
+        (((struct nft_trans_set *)trans->data)->set)
+#define nft_trans_set_id(trans) \
+        (((struct nft_trans_set *)trans->data)->set_id)
+
+struct nft_trans_chain {
+        bool            update;
+        char            name[NFT_CHAIN_MAXNAMELEN];
+        struct nft_stats __percpu *stats;
+        u8              policy;
+};
+
+#define nft_trans_chain_update(trans)   \
+        (((struct nft_trans_chain *)trans->data)->update)
+#define nft_trans_chain_name(trans)     \
+        (((struct nft_trans_chain *)trans->data)->name)
+#define nft_trans_chain_stats(trans)    \
+        (((struct nft_trans_chain *)trans->data)->stats)
+#define nft_trans_chain_policy(trans)   \
+        (((struct nft_trans_chain *)trans->data)->policy)
+
+struct nft_trans_table {
+        bool            update;
+        bool            enable;
+};
+
+#define nft_trans_table_update(trans)   \
+        (((struct nft_trans_table *)trans->data)->update)
+#define nft_trans_table_enable(trans)   \
+        (((struct nft_trans_table *)trans->data)->enable)
+
+struct nft_trans_elem {
+        struct nft_set          *set;
+        struct nft_set_elem     elem;
+};
+
+#define nft_trans_elem_set(trans)       \
+        (((struct nft_trans_elem *)trans->data)->set)
+#define nft_trans_elem(trans)   \
+        (((struct nft_trans_elem *)trans->data)->elem)
+
 static inline struct nft_expr *nft_expr_first(const struct nft_rule *rule)
 {
         return (struct nft_expr *)&rule->data[0];
@@ -385,6 +492,7 @@ static inline void *nft_userdata(const struct nft_rule *rule)
 
 enum nft_chain_flags {
         NFT_BASE_CHAIN                  = 0x1,
+        NFT_CHAIN_INACTIVE              = 0x2,
 };
 
 /**
diff --git a/include/net/netfilter/nft_meta.h b/include/net/netfilter/nft_meta.h
new file mode 100644
index 000000000000..0ee47c3e2e31
--- /dev/null
+++ b/include/net/netfilter/nft_meta.h
@@ -0,0 +1,36 @@
+#ifndef _NFT_META_H_
+#define _NFT_META_H_
+
+struct nft_meta {
+        enum nft_meta_keys      key:8;
+        union {
+                enum nft_registers      dreg:8;
+                enum nft_registers      sreg:8;
+        };
+};
+
+extern const struct nla_policy nft_meta_policy[];
+
+int nft_meta_get_init(const struct nft_ctx *ctx,
+                      const struct nft_expr *expr,
+                      const struct nlattr * const tb[]);
+
+int nft_meta_set_init(const struct nft_ctx *ctx,
+                      const struct nft_expr *expr,
+                      const struct nlattr * const tb[]);
+
+int nft_meta_get_dump(struct sk_buff *skb,
+                      const struct nft_expr *expr);
+
+int nft_meta_set_dump(struct sk_buff *skb,
+                      const struct nft_expr *expr);
+
+void nft_meta_get_eval(const struct nft_expr *expr,
+                       struct nft_data data[NFT_REG_MAX + 1],
+                       const struct nft_pktinfo *pkt);
+
+void nft_meta_set_eval(const struct nft_expr *expr,
+                       struct nft_data data[NFT_REG_MAX + 1],
+                       const struct nft_pktinfo *pkt);
+
+#endif
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index b2704fd0ec80..aec5e12f9f19 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -77,10 +77,17 @@ struct netns_ipv4 {
         int sysctl_ip_no_pmtu_disc;
         int sysctl_ip_fwd_use_pmtu;
 
+        int sysctl_fwmark_reflect;
+        int sysctl_tcp_fwmark_accept;
+
         struct ping_group_range ping_group_range;
 
         atomic_t dev_addr_genid;
 
+#ifdef CONFIG_SYSCTL
+        unsigned long *sysctl_local_reserved_ports;
+#endif
+
 #ifdef CONFIG_IP_MROUTE
 #ifndef CONFIG_IP_MROUTE_MULTIPLE_TABLES
         struct mr_table         *mrt;
diff --git a/include/net/netns/ipv6.h b/include/net/netns/ipv6.h
index 21edaf1f7916..19d3446e59d2 100644
--- a/include/net/netns/ipv6.h
+++ b/include/net/netns/ipv6.h
@@ -30,6 +30,7 @@ struct netns_sysctl_ipv6 {
         int flowlabel_consistency;
         int icmpv6_time;
         int anycast_src_echo_reply;
+        int fwmark_reflect;
 };
 
 struct netns_ipv6 {
diff --git a/include/net/nfc/digital.h b/include/net/nfc/digital.h
index 7655cfe27c34..bdf55c3b7a19 100644
--- a/include/net/nfc/digital.h
+++ b/include/net/nfc/digital.h
@@ -36,6 +36,7 @@ enum {
         NFC_DIGITAL_RF_TECH_212F,
         NFC_DIGITAL_RF_TECH_424F,
         NFC_DIGITAL_RF_TECH_ISO15693,
+        NFC_DIGITAL_RF_TECH_106B,
 
         NFC_DIGITAL_RF_TECH_LAST,
 };
@@ -62,6 +63,9 @@ enum {
         NFC_DIGITAL_FRAMING_ISO15693_INVENTORY,
         NFC_DIGITAL_FRAMING_ISO15693_T5T,
 
+        NFC_DIGITAL_FRAMING_NFCB,
+        NFC_DIGITAL_FRAMING_NFCB_T4T,
+
         NFC_DIGITAL_FRAMING_LAST,
 };
 
diff --git a/include/net/nfc/hci.h b/include/net/nfc/hci.h
index 03c4650b548c..61286db54388 100644
--- a/include/net/nfc/hci.h
+++ b/include/net/nfc/hci.h
@@ -27,6 +27,7 @@ struct nfc_hci_dev;
 struct nfc_hci_ops {
         int (*open) (struct nfc_hci_dev *hdev);
         void (*close) (struct nfc_hci_dev *hdev);
+        int (*load_session) (struct nfc_hci_dev *hdev);
         int (*hci_ready) (struct nfc_hci_dev *hdev);
         /*
          * xmit must always send the complete buffer before
diff --git a/include/net/nfc/nfc.h b/include/net/nfc/nfc.h
index 2e8b40c16274..6c583e244de2 100644
--- a/include/net/nfc/nfc.h
+++ b/include/net/nfc/nfc.h
@@ -264,4 +264,7 @@ int nfc_add_se(struct nfc_dev *dev, u32 se_idx, u16 type);
 int nfc_remove_se(struct nfc_dev *dev, u32 se_idx);
 struct nfc_se *nfc_find_se(struct nfc_dev *dev, u32 se_idx);
 
+void nfc_send_to_raw_sock(struct nfc_dev *dev, struct sk_buff *skb,
+                          u8 payload_type, u8 direction);
+
 #endif /* __NET_NFC_H */
diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
index a2441fb1428f..6da46dcf1049 100644
--- a/include/net/pkt_cls.h
+++ b/include/net/pkt_cls.h
@@ -136,7 +136,7 @@ tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
 
 int tcf_exts_validate(struct net *net, struct tcf_proto *tp,
                       struct nlattr **tb, struct nlattr *rate_tlv,
-                      struct tcf_exts *exts);
+                      struct tcf_exts *exts, bool ovr);
 void tcf_exts_destroy(struct tcf_proto *tp, struct tcf_exts *exts);
 void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
                      struct tcf_exts *src);
diff --git a/include/net/pkt_sched.h b/include/net/pkt_sched.h
index 891d80d2c4d2..ec030cd76616 100644
--- a/include/net/pkt_sched.h
+++ b/include/net/pkt_sched.h
@@ -96,7 +96,7 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,
                                         struct nlattr *tab);
 void qdisc_put_rtab(struct qdisc_rate_table *tab);
 void qdisc_put_stab(struct qdisc_size_table *tab);
-void qdisc_warn_nonwc(char *txt, struct Qdisc *qdisc);
+void qdisc_warn_nonwc(const char *txt, struct Qdisc *qdisc);
 int sch_direct_xmit(struct sk_buff *skb, struct Qdisc *q,
                     struct net_device *dev, struct netdev_queue *txq,
                     spinlock_t *root_lock);
diff --git a/include/net/protocol.h b/include/net/protocol.h
index a7e986b08147..d6fcc1fcdb5b 100644
--- a/include/net/protocol.h
+++ b/include/net/protocol.h
@@ -86,7 +86,6 @@ struct inet_protosw {
         struct proto     *prot;
         const struct proto_ops *ops;
   
-        char             no_check;   /* checksum on rcv/xmit/none? */
         unsigned char    flags;      /* See INET_PROTOSW_* below.  */
 };
 #define INET_PROTOSW_REUSE 0x01      /* Are ports automatically reusable? */
diff --git a/include/net/regulatory.h b/include/net/regulatory.h
index 75fc1f5a948d..259992444e80 100644
--- a/include/net/regulatory.h
+++ b/include/net/regulatory.h
@@ -131,6 +131,11 @@ struct regulatory_request {
  *      all country IE information processed by the regulatory core. This will
  *      override %REGULATORY_COUNTRY_IE_FOLLOW_POWER as all country IEs will
  *      be ignored.
+ * @REGULATORY_ENABLE_RELAX_NO_IR: for devices that wish to allow the
+ *      NO_IR relaxation, which enables transmissions on channels on which
+ *      otherwise initiating radiation is not allowed. This will enable the
+ *      relaxations enabled under the CFG80211_REG_RELAX_NO_IR configuration
+ *      option
  */
 enum ieee80211_regulatory_flags {
         REGULATORY_CUSTOM_REG                   = BIT(0),
@@ -138,6 +143,7 @@ enum ieee80211_regulatory_flags {
         REGULATORY_DISABLE_BEACON_HINTS         = BIT(2),
         REGULATORY_COUNTRY_IE_FOLLOW_POWER      = BIT(3),
         REGULATORY_COUNTRY_IE_IGNORE            = BIT(4),
+        REGULATORY_ENABLE_RELAX_NO_IR           = BIT(5),
 };
 
 struct ieee80211_freq_range {
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index d062f81c692f..624f9857c83e 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -199,7 +199,7 @@ struct tcf_proto_ops {
         int                     (*change)(struct net *net, struct sk_buff *,
                                         struct tcf_proto*, unsigned long,
                                         u32 handle, struct nlattr **,
-                                        unsigned long *);
+                                        unsigned long *, bool);
         int                     (*delete)(struct tcf_proto*, unsigned long);
         void                    (*walk)(struct tcf_proto*, struct tcf_walker *arg);
 
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 0dfcc92600e8..f38588bf3462 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -838,10 +838,10 @@ struct sctp_transport {
         unsigned long sackdelay;
         __u32 sackfreq;
 
-        /* When was the last time (in jiffies) that we heard from this
-         * transport?  We use this to pick new active and retran paths.
+        /* When was the last time that we heard from this transport? We use
+         * this to pick new active and retran paths.
          */
-        unsigned long last_time_heard;
+        ktime_t last_time_heard;
 
         /* Last time(in jiffies) when cwnd is reduced due to the congestion
          * indication based on ECNE chunk.
diff --git a/include/net/secure_seq.h b/include/net/secure_seq.h
index f257486f17be..3f36d45b714a 100644
--- a/include/net/secure_seq.h
+++ b/include/net/secure_seq.h
@@ -3,8 +3,6 @@
 
 #include <linux/types.h>
 
-__u32 secure_ip_id(__be32 daddr);
-__u32 secure_ipv6_id(const __be32 daddr[4]);
 u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport);
 u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
                                __be16 dport);
diff --git a/include/net/snmp.h b/include/net/snmp.h
index 71596261fa99..f1f27fdbb0d5 100644
--- a/include/net/snmp.h
+++ b/include/net/snmp.h
@@ -116,51 +116,49 @@ struct linux_xfrm_mib {
         unsigned long   mibs[LINUX_MIB_XFRMMAX];
 };
 
-#define SNMP_ARRAY_SZ 1
-
 #define DEFINE_SNMP_STAT(type, name)    \
-        __typeof__(type) __percpu *name[SNMP_ARRAY_SZ]
+        __typeof__(type) __percpu *name
 #define DEFINE_SNMP_STAT_ATOMIC(type, name)     \
         __typeof__(type) *name
 #define DECLARE_SNMP_STAT(type, name)   \
-        extern __typeof__(type) __percpu *name[SNMP_ARRAY_SZ]
+        extern __typeof__(type) __percpu *name
 
 #define SNMP_INC_STATS_BH(mib, field)   \
-                        __this_cpu_inc(mib[0]->mibs[field])
+                        __this_cpu_inc(mib->mibs[field])
 
 #define SNMP_INC_STATS_USER(mib, field) \
-                        this_cpu_inc(mib[0]->mibs[field])
+                        this_cpu_inc(mib->mibs[field])
 
 #define SNMP_INC_STATS_ATOMIC_LONG(mib, field)  \
                         atomic_long_inc(&mib->mibs[field])
 
 #define SNMP_INC_STATS(mib, field)      \
-                        this_cpu_inc(mib[0]->mibs[field])
+                        this_cpu_inc(mib->mibs[field])
 
 #define SNMP_DEC_STATS(mib, field)      \
-                        this_cpu_dec(mib[0]->mibs[field])
+                        this_cpu_dec(mib->mibs[field])
 
 #define SNMP_ADD_STATS_BH(mib, field, addend)   \
-                        __this_cpu_add(mib[0]->mibs[field], addend)
+                        __this_cpu_add(mib->mibs[field], addend)
 
 #define SNMP_ADD_STATS_USER(mib, field, addend) \
-                        this_cpu_add(mib[0]->mibs[field], addend)
+                        this_cpu_add(mib->mibs[field], addend)
 
 #define SNMP_ADD_STATS(mib, field, addend)      \
-                        this_cpu_add(mib[0]->mibs[field], addend)
+                        this_cpu_add(mib->mibs[field], addend)
 /*
- * Use "__typeof__(*mib[0]) *ptr" instead of "__typeof__(mib[0]) ptr"
+ * Use "__typeof__(*mib) *ptr" instead of "__typeof__(mib) ptr"
  * to make @ptr a non-percpu pointer.
  */
 #define SNMP_UPD_PO_STATS(mib, basefield, addend)       \
         do { \
-                __typeof__(*mib[0]->mibs) *ptr = mib[0]->mibs;  \
+                __typeof__(*mib->mibs) *ptr = mib->mibs;        \
                 this_cpu_inc(ptr[basefield##PKTS]);             \
                 this_cpu_add(ptr[basefield##OCTETS], addend);   \
         } while (0)
 #define SNMP_UPD_PO_STATS_BH(mib, basefield, addend)    \
         do { \
-                __typeof__(*mib[0]->mibs) *ptr = mib[0]->mibs;  \
+                __typeof__(*mib->mibs) *ptr = mib->mibs;        \
                 __this_cpu_inc(ptr[basefield##PKTS]);           \
                 __this_cpu_add(ptr[basefield##OCTETS], addend); \
         } while (0)
@@ -170,7 +168,7 @@ struct linux_xfrm_mib {
 
 #define SNMP_ADD_STATS64_BH(mib, field, addend)                         \
         do {                                                            \
-                __typeof__(*mib[0]) *ptr = __this_cpu_ptr((mib)[0]);    \
+                __typeof__(*mib) *ptr = __this_cpu_ptr(mib);            \
                 u64_stats_update_begin(&ptr->syncp);                    \
                 ptr->mibs[field] += addend;                             \
                 u64_stats_update_end(&ptr->syncp);                      \
@@ -191,8 +189,8 @@ struct linux_xfrm_mib {
 #define SNMP_INC_STATS64(mib, field) SNMP_ADD_STATS64(mib, field, 1)
 #define SNMP_UPD_PO_STATS64_BH(mib, basefield, addend)                  \
         do {                                                            \
-                __typeof__(*mib[0]) *ptr;                               \
-                ptr = __this_cpu_ptr((mib)[0]);                         \
+                __typeof__(*mib) *ptr;                                  \
+                ptr = __this_cpu_ptr(mib);                              \
                 u64_stats_update_begin(&ptr->syncp);                    \
                 ptr->mibs[basefield##PKTS]++;                           \
                 ptr->mibs[basefield##OCTETS] += addend;                 \
diff --git a/include/net/sock.h b/include/net/sock.h
index 21569cf456ed..07b7fcd60d80 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -243,7 +243,8 @@ struct cg_proto;
   *     @sk_sndbuf: size of send buffer in bytes
   *     @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
   *                %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
-  *     @sk_no_check: %SO_NO_CHECK setting, whether or not checkup packets
+  *     @sk_no_check_tx: %SO_NO_CHECK setting, set checksum in TX packets
+  *     @sk_no_check_rx: allow zero checksum in RX packets
   *     @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
   *     @sk_route_nocaps: forbidden route capabilities (e.g NETIF_F_GSO_MASK)
   *     @sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
@@ -371,7 +372,8 @@ struct sock {
         struct sk_buff_head     sk_write_queue;
         kmemcheck_bitfield_begin(flags);
         unsigned int            sk_shutdown  : 2,
-                                sk_no_check  : 2,
+                                sk_no_check_tx : 1,
+                                sk_no_check_rx : 1,
                                 sk_userlocks : 4,
                                 sk_protocol  : 8,
                                 sk_type      : 16;
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 87d877408188..7286db80e8b8 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -220,8 +220,6 @@ void tcp_time_wait(struct sock *sk, int state, int timeo);
 #define TFO_SERVER_ENABLE       2
 #define TFO_CLIENT_NO_COOKIE    4       /* Data in SYN w/o cookie option */
 
-/* Process SYN data but skip cookie validation */
-#define TFO_SERVER_COOKIE_NOT_CHKED     0x100
 /* Accept SYN data w/o any cookie option */
 #define TFO_SERVER_COOKIE_NOT_REQD      0x200
 
@@ -230,10 +228,6 @@ void tcp_time_wait(struct sock *sk, int state, int timeo);
  */
 #define TFO_SERVER_WO_SOCKOPT1  0x400
 #define TFO_SERVER_WO_SOCKOPT2  0x800
-/* Always create TFO child sockets on a TFO listener even when
- * cookie/data not present. (For testing purpose!)
- */
-#define TFO_SERVER_ALWAYS       0x1000
 
 extern struct inet_timewait_death_row tcp_death_row;
 
@@ -541,7 +535,7 @@ void tcp_retransmit_timer(struct sock *sk);
 void tcp_xmit_retransmit_queue(struct sock *);
 void tcp_simple_retransmit(struct sock *);
 int tcp_trim_head(struct sock *, struct sk_buff *, u32);
-int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int);
+int tcp_fragment(struct sock *, struct sk_buff *, u32, unsigned int, gfp_t);
 
 void tcp_send_probe0(struct sock *);
 void tcp_send_partial(struct sock *);
@@ -558,7 +552,6 @@ void tcp_send_loss_probe(struct sock *sk);
 bool tcp_schedule_loss_probe(struct sock *sk);
 
 /* tcp_input.c */
-void tcp_cwnd_application_limited(struct sock *sk);
 void tcp_resume_early_retransmit(struct sock *sk);
 void tcp_rearm_rto(struct sock *sk);
 void tcp_reset(struct sock *sk);
@@ -797,7 +790,7 @@ struct tcp_congestion_ops {
         /* return slow start threshold (required) */
         u32 (*ssthresh)(struct sock *sk);
         /* do new cwnd calculation (required) */
-        void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked, u32 in_flight);
+        void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked);
         /* call before changing ca_state (optional) */
         void (*set_state)(struct sock *sk, u8 new_state);
         /* call when cwnd event occurs (optional) */
@@ -829,7 +822,7 @@ void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w);
 
 extern struct tcp_congestion_ops tcp_init_congestion_ops;
 u32 tcp_reno_ssthresh(struct sock *sk);
-void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked, u32 in_flight);
+void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked);
 extern struct tcp_congestion_ops tcp_reno;
 
 static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)
@@ -975,7 +968,30 @@ static inline u32 tcp_wnd_end(const struct tcp_sock *tp)
 {
         return tp->snd_una + tp->snd_wnd;
 }
-bool tcp_is_cwnd_limited(const struct sock *sk, u32 in_flight);
+
+/* We follow the spirit of RFC2861 to validate cwnd but implement a more
+ * flexible approach. The RFC suggests cwnd should not be raised unless
+ * it was fully used previously. And that's exactly what we do in
+ * congestion avoidance mode. But in slow start we allow cwnd to grow
+ * as long as the application has used half the cwnd.
+ * Example :
+ *    cwnd is 10 (IW10), but application sends 9 frames.
+ *    We allow cwnd to reach 18 when all frames are ACKed.
+ * This check is safe because it's as aggressive as slow start which already
+ * risks 100% overshoot. The advantage is that we discourage application to
+ * either send more filler packets or data to artificially blow up the cwnd
+ * usage, and allow application-limited process to probe bw more aggressively.
+ */
+static inline bool tcp_is_cwnd_limited(const struct sock *sk)
+{
+        const struct tcp_sock *tp = tcp_sk(sk);
+
+        /* If in slow start, ensure cwnd grows to twice what was ACKed. */
+        if (tp->snd_cwnd <= tp->snd_ssthresh)
+                return tp->snd_cwnd < 2 * tp->max_packets_out;
+
+        return tp->is_cwnd_limited;
+}
 
 static inline void tcp_check_probe_timer(struct sock *sk)
 {
@@ -1103,6 +1119,9 @@ static inline void tcp_openreq_init(struct request_sock *req,
         ireq->ir_num = ntohs(tcp_hdr(skb)->dest);
 }
 
+extern void tcp_openreq_init_rwin(struct request_sock *req,
+                                  struct sock *sk, struct dst_entry *dst);
+
 void tcp_enter_memory_pressure(struct sock *sk);
 
 static inline int keepalive_intvl_when(const struct tcp_sock *tp)
@@ -1312,8 +1331,10 @@ void tcp_free_fastopen_req(struct tcp_sock *tp);
 
 extern struct tcp_fastopen_context __rcu *tcp_fastopen_ctx;
 int tcp_fastopen_reset_cipher(void *key, unsigned int len);
-void tcp_fastopen_cookie_gen(__be32 src, __be32 dst,
-                             struct tcp_fastopen_cookie *foc);
+bool tcp_try_fastopen(struct sock *sk, struct sk_buff *skb,
+                      struct request_sock *req,
+                      struct tcp_fastopen_cookie *foc,
+                      struct dst_entry *dst);
 void tcp_fastopen_init_key_once(bool publish);
 #define TCP_FASTOPEN_KEY_LENGTH 16
 
diff --git a/include/net/tso.h b/include/net/tso.h
new file mode 100644
index 000000000000..47e5444f7d15
--- /dev/null
+++ b/include/net/tso.h
@@ -0,0 +1,20 @@
+#ifndef _TSO_H
+#define _TSO_H
+
+#include <net/ip.h>
+
+struct tso_t {
+        int next_frag_idx;
+        void *data;
+        size_t size;
+        u16 ip_id;
+        u32 tcp_seq;
+};
+
+int tso_count_descs(struct sk_buff *skb);
+void tso_build_hdr(struct sk_buff *skb, char *hdr, struct tso_t *tso,
+                   int size, bool is_last);
+void tso_build_data(struct sk_buff *skb, struct tso_t *tso, int size);
+void tso_start(struct sk_buff *skb, struct tso_t *tso);
+
+#endif  /* _TSO_H */
diff --git a/include/net/udp.h b/include/net/udp.h
index a24f0f3e107f..2ecfc6e15609 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -95,15 +95,6 @@ static inline struct udp_hslot *udp_hashslot2(struct udp_table *table,
         return &table->hash2[hash & table->mask];
 }
 
-/* Note: this must match 'valbool' in sock_setsockopt */
-#define UDP_CSUM_NOXMIT         1
-
-/* Used by SunRPC/xprt layer. */
-#define UDP_CSUM_NORCV          2
-
-/* Default, as per the RFC, is to always do csums. */
-#define UDP_CSUM_DEFAULT        0
-
 extern struct proto udp_prot;
 
 extern atomic_long_t udp_memory_allocated;
@@ -156,6 +147,15 @@ static inline __wsum udp_csum(struct sk_buff *skb)
         return csum;
 }
 
+static inline __sum16 udp_v4_check(int len, __be32 saddr,
+                                   __be32 daddr, __wsum base)
+{
+        return csum_tcpudp_magic(saddr, daddr, len, IPPROTO_UDP, base);
+}
+
+void udp_set_csum(bool nocheck, struct sk_buff *skb,
+                  __be32 saddr, __be32 daddr, int len);
+
 /* hash routines shared between UDPv4/6 and UDP-Litev4/6 */
 static inline void udp_lib_hash(struct sock *sk)
 {
diff --git a/include/net/vxlan.h b/include/net/vxlan.h
index 5deef1ae78c9..12196ce661d9 100644
--- a/include/net/vxlan.h
+++ b/include/net/vxlan.h
@@ -24,16 +24,26 @@ struct vxlan_sock {
         struct udp_offload udp_offloads;
 };
 
+#define VXLAN_F_LEARN                   0x01
+#define VXLAN_F_PROXY                   0x02
+#define VXLAN_F_RSC                     0x04
+#define VXLAN_F_L2MISS                  0x08
+#define VXLAN_F_L3MISS                  0x10
+#define VXLAN_F_IPV6                    0x20
+#define VXLAN_F_UDP_CSUM                0x40
+#define VXLAN_F_UDP_ZERO_CSUM6_TX       0x80
+#define VXLAN_F_UDP_ZERO_CSUM6_RX       0x100
+
 struct vxlan_sock *vxlan_sock_add(struct net *net, __be16 port,
                                   vxlan_rcv_t *rcv, void *data,
-                                  bool no_share, bool ipv6);
+                                  bool no_share, u32 flags);
 
 void vxlan_sock_release(struct vxlan_sock *vs);
 
 int vxlan_xmit_skb(struct vxlan_sock *vs,
                    struct rtable *rt, struct sk_buff *skb,
                    __be32 src, __be32 dst, __u8 tos, __u8 ttl, __be16 df,
-                   __be16 src_port, __be16 dst_port, __be32 vni);
+                   __be16 src_port, __be16 dst_port, __be32 vni, bool xnet);
 
 __be16 vxlan_src_port(__u16 port_min, __u16 port_max, struct sk_buff *skb);
 
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 116e9c7e19cb..721e9c3b11bd 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -691,13 +691,6 @@ struct xfrm_spi_skb_cb {
 
 #define XFRM_SPI_SKB_CB(__skb) ((struct xfrm_spi_skb_cb *)&((__skb)->cb[0]))
 
-/* Audit Information */
-struct xfrm_audit {
-        u32     secid;
-        kuid_t  loginuid;
-        unsigned int sessionid;
-};
-
 #ifdef CONFIG_AUDITSYSCALL
 static inline struct audit_buffer *xfrm_audit_start(const char *op)
 {
@@ -713,30 +706,24 @@ static inline struct audit_buffer *xfrm_audit_start(const char *op)
         return audit_buf;
 }
 
-static inline void xfrm_audit_helper_usrinfo(kuid_t auid, unsigned int ses, u32 secid,
+static inline void xfrm_audit_helper_usrinfo(bool task_valid,
                                              struct audit_buffer *audit_buf)
 {
-        char *secctx;
-        u32 secctx_len;
-
-        audit_log_format(audit_buf, " auid=%u ses=%u",
-                         from_kuid(&init_user_ns, auid), ses);
-        if (secid != 0 &&
-            security_secid_to_secctx(secid, &secctx, &secctx_len) == 0) {
-                audit_log_format(audit_buf, " subj=%s", secctx);
-                security_release_secctx(secctx, secctx_len);
-        } else
-                audit_log_task_context(audit_buf);
-}
-
-void xfrm_audit_policy_add(struct xfrm_policy *xp, int result, kuid_t auid,
-                           unsigned int ses, u32 secid);
-void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result, kuid_t auid,
-                              unsigned int ses, u32 secid);
-void xfrm_audit_state_add(struct xfrm_state *x, int result, kuid_t auid,
-                          unsigned int ses, u32 secid);
-void xfrm_audit_state_delete(struct xfrm_state *x, int result, kuid_t auid,
-                             unsigned int ses, u32 secid);
+        const unsigned int auid = from_kuid(&init_user_ns, task_valid ?
+                                            audit_get_loginuid(current) :
+                                            INVALID_UID);
+        const unsigned int ses = task_valid ? audit_get_sessionid(current) :
+                (unsigned int) -1;
+
+        audit_log_format(audit_buf, " auid=%u ses=%u", auid, ses);
+        audit_log_task_context(audit_buf);
+}
+
+void xfrm_audit_policy_add(struct xfrm_policy *xp, int result, bool task_valid);
+void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
+                              bool task_valid);
+void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid);
+void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid);
 void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
                                       struct sk_buff *skb);
 void xfrm_audit_state_replay(struct xfrm_state *x, struct sk_buff *skb,
@@ -749,22 +736,22 @@ void xfrm_audit_state_icvfail(struct xfrm_state *x, struct sk_buff *skb,
 #else
 
 static inline void xfrm_audit_policy_add(struct xfrm_policy *xp, int result,
-                                  kuid_t auid, unsigned int ses, u32 secid)
+                                         bool task_valid)
 {
 }
 
 static inline void xfrm_audit_policy_delete(struct xfrm_policy *xp, int result,
-                                  kuid_t auid, unsigned int ses, u32 secid)
+                                            bool task_valid)
 {
 }
 
 static inline void xfrm_audit_state_add(struct xfrm_state *x, int result,
-                                 kuid_t auid, unsigned int ses, u32 secid)
+                                        bool task_valid)
 {
 }
 
 static inline void xfrm_audit_state_delete(struct xfrm_state *x, int result,
-                                    kuid_t auid, unsigned int ses, u32 secid)
+                                           bool task_valid)
 {
 }
 
@@ -1508,7 +1495,7 @@ struct xfrmk_spdinfo {
 
 struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq);
 int xfrm_state_delete(struct xfrm_state *x);
-int xfrm_state_flush(struct net *net, u8 proto, struct xfrm_audit *audit_info);
+int xfrm_state_flush(struct net *net, u8 proto, bool task_valid);
 void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si);
 void xfrm_spd_getinfo(struct net *net, struct xfrmk_spdinfo *si);
 u32 xfrm_replay_seqhi(struct xfrm_state *x, __be32 net_seq);
@@ -1603,7 +1590,7 @@ struct xfrm_policy *xfrm_policy_bysel_ctx(struct net *net, u32 mark,
                                           int *err);
 struct xfrm_policy *xfrm_policy_byid(struct net *net, u32 mark, u8, int dir,
                                      u32 id, int delete, int *err);
-int xfrm_policy_flush(struct net *net, u8 type, struct xfrm_audit *audit_info);
+int xfrm_policy_flush(struct net *net, u8 type, bool task_valid);
 u32 xfrm_get_acqseq(void);
 int verify_spi_info(u8 proto, u32 min, u32 max);
 int xfrm_alloc_spi(struct xfrm_state *x, u32 minspi, u32 maxspi);
diff --git a/include/uapi/linux/audit.h b/include/uapi/linux/audit.h
index 4c31a366be16..cf6714752b69 100644
--- a/include/uapi/linux/audit.h
+++ b/include/uapi/linux/audit.h
@@ -385,6 +385,14 @@ enum {
  */
 #define AUDIT_MESSAGE_TEXT_MAX  8560
 
+/* Multicast Netlink socket groups (default up to 32) */
+enum audit_nlgrps {
+        AUDIT_NLGRP_NONE,       /* Group 0 not used */
+        AUDIT_NLGRP_READLOG,    /* "best effort" read only socket */
+        __AUDIT_NLGRP_MAX
+};
+#define AUDIT_NLGRP_MAX                (__AUDIT_NLGRP_MAX - 1)
+
 struct audit_status {
         __u32           mask;           /* Bit mask for valid entries */
         __u32           enabled;        /* 1 = enabled, 0 = disabled */
diff --git a/include/uapi/linux/can.h b/include/uapi/linux/can.h
index 5d9d1d140718..41892f720057 100644
--- a/include/uapi/linux/can.h
+++ b/include/uapi/linux/can.h
@@ -42,8 +42,8 @@
  * DAMAGE.
  */
 
-#ifndef CAN_H
-#define CAN_H
+#ifndef _UAPI_CAN_H
+#define _UAPI_CAN_H
 
 #include <linux/types.h>
 #include <linux/socket.h>
@@ -191,4 +191,4 @@ struct can_filter {
 
 #define CAN_INV_FILTER 0x20000000U /* to be set in can_filter.can_id */
 
-#endif /* CAN_H */
+#endif /* !_UAPI_CAN_H */
diff --git a/include/uapi/linux/can/bcm.h b/include/uapi/linux/can/bcm.h
index 382251a1d214..89ddb9dc9bdf 100644
--- a/include/uapi/linux/can/bcm.h
+++ b/include/uapi/linux/can/bcm.h
@@ -41,8 +41,8 @@
  * DAMAGE.
  */
 
-#ifndef CAN_BCM_H
-#define CAN_BCM_H
+#ifndef _UAPI_CAN_BCM_H
+#define _UAPI_CAN_BCM_H
 
 #include <linux/types.h>
 #include <linux/can.h>
@@ -95,4 +95,4 @@ enum {
 #define TX_RESET_MULTI_IDX  0x0200
 #define RX_RTR_FRAME        0x0400
 
-#endif /* CAN_BCM_H */
+#endif /* !_UAPI_CAN_BCM_H */
diff --git a/include/uapi/linux/can/error.h b/include/uapi/linux/can/error.h
index b63204545320..c247446ab25a 100644
--- a/include/uapi/linux/can/error.h
+++ b/include/uapi/linux/can/error.h
@@ -41,8 +41,8 @@
  * DAMAGE.
  */
 
-#ifndef CAN_ERROR_H
-#define CAN_ERROR_H
+#ifndef _UAPI_CAN_ERROR_H
+#define _UAPI_CAN_ERROR_H
 
 #define CAN_ERR_DLC 8 /* dlc for error message frames */
 
@@ -120,4 +120,4 @@
 
 /* controller specific additional information / data[5..7] */
 
-#endif /* CAN_ERROR_H */
+#endif /* _UAPI_CAN_ERROR_H */
diff --git a/include/uapi/linux/can/gw.h b/include/uapi/linux/can/gw.h
index 844c8964bdfe..3e6184cf2f6d 100644
--- a/include/uapi/linux/can/gw.h
+++ b/include/uapi/linux/can/gw.h
@@ -41,8 +41,8 @@
  * DAMAGE.
  */
 
-#ifndef CAN_GW_H
-#define CAN_GW_H
+#ifndef _UAPI_CAN_GW_H
+#define _UAPI_CAN_GW_H
 
 #include <linux/types.h>
 #include <linux/can.h>
@@ -200,4 +200,4 @@ enum {
  *         Beware of sending unpacked or aligned structs!
  */
 
-#endif
+#endif /* !_UAPI_CAN_GW_H */
diff --git a/include/uapi/linux/can/netlink.h b/include/uapi/linux/can/netlink.h
index 7e2e1863db16..813d11f54977 100644
--- a/include/uapi/linux/can/netlink.h
+++ b/include/uapi/linux/can/netlink.h
@@ -15,8 +15,8 @@
  * GNU General Public License for more details.
  */
 
-#ifndef CAN_NETLINK_H
-#define CAN_NETLINK_H
+#ifndef _UAPI_CAN_NETLINK_H
+#define _UAPI_CAN_NETLINK_H
 
 #include <linux/types.h>
 
@@ -130,4 +130,4 @@ enum {
 
 #define IFLA_CAN_MAX    (__IFLA_CAN_MAX - 1)
 
-#endif /* CAN_NETLINK_H */
+#endif /* !_UAPI_CAN_NETLINK_H */
diff --git a/include/uapi/linux/can/raw.h b/include/uapi/linux/can/raw.h
index c7d8c334e0ce..78ec76fd89a6 100644
--- a/include/uapi/linux/can/raw.h
+++ b/include/uapi/linux/can/raw.h
@@ -42,8 +42,8 @@
  * DAMAGE.
  */
 
-#ifndef CAN_RAW_H
-#define CAN_RAW_H
+#ifndef _UAPI_CAN_RAW_H
+#define _UAPI_CAN_RAW_H
 
 #include <linux/can.h>
 
@@ -59,4 +59,4 @@ enum {
         CAN_RAW_FD_FRAMES,      /* allow CAN FD frames (default:off) */
 };
 
-#endif
+#endif /* !_UAPI_CAN_RAW_H */
diff --git a/include/uapi/linux/capability.h b/include/uapi/linux/capability.h
index 154dd6d3c8fe..12c37a197d24 100644
--- a/include/uapi/linux/capability.h
+++ b/include/uapi/linux/capability.h
@@ -347,7 +347,12 @@ struct vfs_cap_data {
 
 #define CAP_BLOCK_SUSPEND    36
 
-#define CAP_LAST_CAP         CAP_BLOCK_SUSPEND
+/* Allow reading the audit log via multicast netlink socket */
+
+#define CAP_AUDIT_READ          37
+
+
+#define CAP_LAST_CAP         CAP_AUDIT_READ
 
 #define cap_valid(x) ((x) >= 0 && (x) <= CAP_LAST_CAP)
 
diff --git a/include/uapi/linux/ethtool.h b/include/uapi/linux/ethtool.h
index fd161e91b6d7..e3c7a719c76b 100644
--- a/include/uapi/linux/ethtool.h
+++ b/include/uapi/linux/ethtool.h
@@ -847,6 +847,38 @@ struct ethtool_rxfh_indir {
 };
 
 /**
+ * struct ethtool_rxfh - command to get/set RX flow hash indir or/and hash key.
+ * @cmd: Specific command number - %ETHTOOL_GRSSH or %ETHTOOL_SRSSH
+ * @rss_context: RSS context identifier.
+ * @indir_size: On entry, the array size of the user buffer for the
+ *      indirection table, which may be zero, or (for %ETHTOOL_SRSSH),
+ *      %ETH_RXFH_INDIR_NO_CHANGE.  On return from %ETHTOOL_GRSSH,
+ *      the array size of the hardware indirection table.
+ * @key_size: On entry, the array size of the user buffer for the hash key,
+ *      which may be zero.  On return from %ETHTOOL_GRSSH, the size of the
+ *      hardware hash key.
+ * @rsvd:       Reserved for future extensions.
+ * @rss_config: RX ring/queue index for each hash value i.e., indirection table
+ *      of @indir_size __u32 elements, followed by hash key of @key_size
+ *      bytes.
+ *
+ * For %ETHTOOL_GRSSH, a @indir_size and key_size of zero means that only the
+ * size should be returned.  For %ETHTOOL_SRSSH, an @indir_size of
+ * %ETH_RXFH_INDIR_NO_CHANGE means that indir table setting is not requested
+ * and a @indir_size of zero means the indir table should be reset to default
+ * values.
+ */
+struct ethtool_rxfh {
+        __u32   cmd;
+        __u32   rss_context;
+        __u32   indir_size;
+        __u32   key_size;
+        __u32   rsvd[2];
+        __u32   rss_config[0];
+};
+#define ETH_RXFH_INDIR_NO_CHANGE        0xffffffff
+
+/**
  * struct ethtool_rx_ntuple_flow_spec - specification for RX flow filter
  * @flow_type: Type of match to perform, e.g. %TCP_V4_FLOW
  * @h_u: Flow field values to match (dependent on @flow_type)
@@ -1118,6 +1150,9 @@ enum ethtool_sfeatures_retval_bits {
 #define ETHTOOL_GEEE            0x00000044 /* Get EEE settings */
 #define ETHTOOL_SEEE            0x00000045 /* Set EEE settings */
 
+#define ETHTOOL_GRSSH           0x00000046 /* Get RX flow hash configuration */
+#define ETHTOOL_SRSSH           0x00000047 /* Set RX flow hash configuration */
+
 /* compatibility with older code */
 #define SPARC_ETH_GSET          ETHTOOL_GSET
 #define SPARC_ETH_SSET          ETHTOOL_SSET
diff --git a/include/uapi/linux/filter.h b/include/uapi/linux/filter.h
index 8eb9ccaa5b48..253b4d42cf2b 100644
--- a/include/uapi/linux/filter.h
+++ b/include/uapi/linux/filter.h
@@ -130,7 +130,8 @@ struct sock_fprog {	/* Required for SO_ATTACH_FILTER. */
 #define SKF_AD_VLAN_TAG 44
 #define SKF_AD_VLAN_TAG_PRESENT 48
 #define SKF_AD_PAY_OFFSET       52
-#define SKF_AD_MAX      56
+#define SKF_AD_RANDOM   56
+#define SKF_AD_MAX      60
 #define SKF_NET_OFF   (-0x100000)
 #define SKF_LL_OFF    (-0x200000)
 
diff --git a/include/uapi/linux/if_fddi.h b/include/uapi/linux/if_fddi.h
index 0d36909c3aef..1086cd9f6754 100644
--- a/include/uapi/linux/if_fddi.h
+++ b/include/uapi/linux/if_fddi.h
@@ -30,74 +30,76 @@
  *  Define max and min legal sizes.  The frame sizes do not include
  *  4 byte FCS/CRC (frame check sequence).
  */
-#define FDDI_K_ALEN                     6               /* Octets in one FDDI address */
-#define FDDI_K_8022_HLEN        16              /* Total octets in 802.2 header */
-#define FDDI_K_SNAP_HLEN        21              /* Total octets in 802.2 SNAP header */
-#define FDDI_K_8022_ZLEN        16              /* Min octets in 802.2 frame sans FCS */
-#define FDDI_K_SNAP_ZLEN        21              /* Min octets in 802.2 SNAP frame sans FCS */
+#define FDDI_K_ALEN             6       /* Octets in one FDDI address */
+#define FDDI_K_8022_HLEN        16      /* Total octets in 802.2 header */
+#define FDDI_K_SNAP_HLEN        21      /* Total octets in 802.2 SNAP header */
+#define FDDI_K_8022_ZLEN        16      /* Min octets in 802.2 frame sans
+                                           FCS */
+#define FDDI_K_SNAP_ZLEN        21      /* Min octets in 802.2 SNAP frame sans
+                                           FCS */
 #define FDDI_K_8022_DLEN        4475    /* Max octets in 802.2 payload */
 #define FDDI_K_SNAP_DLEN        4470    /* Max octets in 802.2 SNAP payload */
-#define FDDI_K_LLC_ZLEN         13              /* Min octets in LLC frame sans FCS */
+#define FDDI_K_LLC_ZLEN         13      /* Min octets in LLC frame sans FCS */
 #define FDDI_K_LLC_LEN          4491    /* Max octets in LLC frame sans FCS */
+#define FDDI_K_OUI_LEN          3       /* Octets in OUI in 802.2 SNAP
+                                           header */
 
 /* Define FDDI Frame Control (FC) Byte values */
-#define FDDI_FC_K_VOID                                  0x00    
-#define FDDI_FC_K_NON_RESTRICTED_TOKEN  0x80    
-#define FDDI_FC_K_RESTRICTED_TOKEN              0xC0    
-#define FDDI_FC_K_SMT_MIN                               0x41
-#define FDDI_FC_K_SMT_MAX                               0x4F
-#define FDDI_FC_K_MAC_MIN                               0xC1
-#define FDDI_FC_K_MAC_MAX                               0xCF    
-#define FDDI_FC_K_ASYNC_LLC_MIN                 0x50
-#define FDDI_FC_K_ASYNC_LLC_DEF                 0x54
-#define FDDI_FC_K_ASYNC_LLC_MAX                 0x5F
-#define FDDI_FC_K_SYNC_LLC_MIN                  0xD0
-#define FDDI_FC_K_SYNC_LLC_MAX                  0xD7
-#define FDDI_FC_K_IMPLEMENTOR_MIN               0x60
-#define FDDI_FC_K_IMPLEMENTOR_MAX               0x6F
-#define FDDI_FC_K_RESERVED_MIN                  0x70
-#define FDDI_FC_K_RESERVED_MAX                  0x7F
+#define FDDI_FC_K_VOID                  0x00
+#define FDDI_FC_K_NON_RESTRICTED_TOKEN  0x80
+#define FDDI_FC_K_RESTRICTED_TOKEN      0xC0
+#define FDDI_FC_K_SMT_MIN               0x41
+#define FDDI_FC_K_SMT_MAX               0x4F
+#define FDDI_FC_K_MAC_MIN               0xC1
+#define FDDI_FC_K_MAC_MAX               0xCF
+#define FDDI_FC_K_ASYNC_LLC_MIN         0x50
+#define FDDI_FC_K_ASYNC_LLC_DEF         0x54
+#define FDDI_FC_K_ASYNC_LLC_MAX         0x5F
+#define FDDI_FC_K_SYNC_LLC_MIN          0xD0
+#define FDDI_FC_K_SYNC_LLC_MAX          0xD7
+#define FDDI_FC_K_IMPLEMENTOR_MIN       0x60
+#define FDDI_FC_K_IMPLEMENTOR_MAX       0x6F
+#define FDDI_FC_K_RESERVED_MIN          0x70
+#define FDDI_FC_K_RESERVED_MAX          0x7F
 
 /* Define LLC and SNAP constants */
-#define FDDI_EXTENDED_SAP       0xAA
+#define FDDI_EXTENDED_SAP               0xAA
 #define FDDI_UI_CMD                     0x03
 
 /* Define 802.2 Type 1 header */
 struct fddi_8022_1_hdr {
-        __u8    dsap;                                   /* destination service access point */
-        __u8    ssap;                                   /* source service access point */
-        __u8    ctrl;                                   /* control byte #1 */
+        __u8    dsap;                   /* destination service access point */
+        __u8    ssap;                   /* source service access point */
+        __u8    ctrl;                   /* control byte #1 */
 } __attribute__((packed));
 
 /* Define 802.2 Type 2 header */
 struct fddi_8022_2_hdr {
-        __u8    dsap;                                   /* destination service access point */
-        __u8    ssap;                                   /* source service access point */
-        __u8    ctrl_1;                                 /* control byte #1 */
-        __u8    ctrl_2;                                 /* control byte #2 */
+        __u8    dsap;                   /* destination service access point */
+        __u8    ssap;                   /* source service access point */
+        __u8    ctrl_1;                 /* control byte #1 */
+        __u8    ctrl_2;                 /* control byte #2 */
 } __attribute__((packed));
 
 /* Define 802.2 SNAP header */
-#define FDDI_K_OUI_LEN  3
 struct fddi_snap_hdr {
-        __u8    dsap;                                   /* always 0xAA */
-        __u8    ssap;                                   /* always 0xAA */
-        __u8    ctrl;                                   /* always 0x03 */
+        __u8    dsap;                   /* always 0xAA */
+        __u8    ssap;                   /* always 0xAA */
+        __u8    ctrl;                   /* always 0x03 */
         __u8    oui[FDDI_K_OUI_LEN];    /* organizational universal id */
-        __be16  ethertype;                              /* packet type ID field */
+        __be16  ethertype;              /* packet type ID field */
 } __attribute__((packed));
 
 /* Define FDDI LLC frame header */
 struct fddihdr {
-        __u8    fc;                                             /* frame control */
-        __u8    daddr[FDDI_K_ALEN];             /* destination address */
-        __u8    saddr[FDDI_K_ALEN];             /* source address */
-        union
-                {
-                struct fddi_8022_1_hdr          llc_8022_1;
-                struct fddi_8022_2_hdr          llc_8022_2;
-                struct fddi_snap_hdr            llc_snap;
-                } hdr;
+        __u8    fc;                     /* frame control */
+        __u8    daddr[FDDI_K_ALEN];     /* destination address */
+        __u8    saddr[FDDI_K_ALEN];     /* source address */
+        union {
+                struct fddi_8022_1_hdr  llc_8022_1;
+                struct fddi_8022_2_hdr  llc_8022_2;
+                struct fddi_snap_hdr    llc_snap;
+        } hdr;
 } __attribute__((packed));
 
 
diff --git a/include/uapi/linux/if_link.h b/include/uapi/linux/if_link.h
index 9a7f7ace6649..b38534895db5 100644
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -319,6 +319,9 @@ enum {
         IFLA_VXLAN_PORT,        /* destination port */
         IFLA_VXLAN_GROUP6,
         IFLA_VXLAN_LOCAL6,
+        IFLA_VXLAN_UDP_CSUM,
+        IFLA_VXLAN_UDP_ZERO_CSUM6_TX,
+        IFLA_VXLAN_UDP_ZERO_CSUM6_RX,
         __IFLA_VXLAN_MAX
 };
 #define IFLA_VXLAN_MAX  (__IFLA_VXLAN_MAX - 1)
@@ -399,9 +402,10 @@ enum {
         IFLA_VF_UNSPEC,
         IFLA_VF_MAC,            /* Hardware queue specific attributes */
         IFLA_VF_VLAN,
-        IFLA_VF_TX_RATE,        /* TX Bandwidth Allocation */
+        IFLA_VF_TX_RATE,        /* Max TX Bandwidth Allocation */
         IFLA_VF_SPOOFCHK,       /* Spoof Checking on/off switch */
         IFLA_VF_LINK_STATE,     /* link state enable/disable/auto switch */
+        IFLA_VF_RATE,           /* Min and Max TX Bandwidth Allocation */
         __IFLA_VF_MAX,
 };
 
@@ -423,6 +427,12 @@ struct ifla_vf_tx_rate {
         __u32 rate; /* Max TX bandwidth in Mbps, 0 disables throttling */
 };
 
+struct ifla_vf_rate {
+        __u32 vf;
+        __u32 min_tx_rate; /* Min Bandwidth in Mbps */
+        __u32 max_tx_rate; /* Max Bandwidth in Mbps */
+};
+
 struct ifla_vf_spoofchk {
         __u32 vf;
         __u32 setting;
diff --git a/include/uapi/linux/if_tunnel.h b/include/uapi/linux/if_tunnel.h
index aee73d0611fb..3bce9e9d9f7c 100644
--- a/include/uapi/linux/if_tunnel.h
+++ b/include/uapi/linux/if_tunnel.h
@@ -100,7 +100,7 @@ enum {
 #define IFLA_GRE_MAX    (__IFLA_GRE_MAX - 1)
 
 /* VTI-mode i_flags */
-#define VTI_ISVTI 0x0001
+#define VTI_ISVTI ((__force __be16)0x0001)
 
 enum {
         IFLA_VTI_UNSPEC,
diff --git a/include/uapi/linux/l2tp.h b/include/uapi/linux/l2tp.h
index 8adb68160327..21caa2631c20 100644
--- a/include/uapi/linux/l2tp.h
+++ b/include/uapi/linux/l2tp.h
@@ -124,6 +124,8 @@ enum {
         L2TP_ATTR_STATS,                /* nested */
         L2TP_ATTR_IP6_SADDR,            /* struct in6_addr */
         L2TP_ATTR_IP6_DADDR,            /* struct in6_addr */
+        L2TP_ATTR_UDP_ZERO_CSUM6_TX,    /* u8 */
+        L2TP_ATTR_UDP_ZERO_CSUM6_RX,    /* u8 */
         __L2TP_ATTR_MAX,
 };
 
diff --git a/include/uapi/linux/neighbour.h b/include/uapi/linux/neighbour.h
index d3ef583104e0..4a1d7e96dfe3 100644
--- a/include/uapi/linux/neighbour.h
+++ b/include/uapi/linux/neighbour.h
@@ -24,6 +24,7 @@ enum {
         NDA_PORT,
         NDA_VNI,
         NDA_IFINDEX,
+        NDA_MASTER,
         __NDA_MAX
 };
 
diff --git a/include/uapi/linux/netfilter/nf_tables.h b/include/uapi/linux/netfilter/nf_tables.h
index c88ccbfda5f1..2a88f645a5d8 100644
--- a/include/uapi/linux/netfilter/nf_tables.h
+++ b/include/uapi/linux/netfilter/nf_tables.h
@@ -212,6 +212,29 @@ enum nft_set_flags {
 };
 
 /**
+ * enum nft_set_policies - set selection policy
+ *
+ * @NFT_SET_POL_PERFORMANCE: prefer high performance over low memory use
+ * @NFT_SET_POL_MEMORY: prefer low memory use over high performance
+ */
+enum nft_set_policies {
+        NFT_SET_POL_PERFORMANCE,
+        NFT_SET_POL_MEMORY,
+};
+
+/**
+ * enum nft_set_desc_attributes - set element description
+ *
+ * @NFTA_SET_DESC_SIZE: number of elements in set (NLA_U32)
+ */
+enum nft_set_desc_attributes {
+        NFTA_SET_DESC_UNSPEC,
+        NFTA_SET_DESC_SIZE,
+        __NFTA_SET_DESC_MAX
+};
+#define NFTA_SET_DESC_MAX       (__NFTA_SET_DESC_MAX - 1)
+
+/**
  * enum nft_set_attributes - nf_tables set netlink attributes
  *
  * @NFTA_SET_TABLE: table name (NLA_STRING)
@@ -221,6 +244,9 @@ enum nft_set_flags {
  * @NFTA_SET_KEY_LEN: key data length (NLA_U32)
  * @NFTA_SET_DATA_TYPE: mapping data type (NLA_U32)
  * @NFTA_SET_DATA_LEN: mapping data length (NLA_U32)
+ * @NFTA_SET_POLICY: selection policy (NLA_U32)
+ * @NFTA_SET_DESC: set description (NLA_NESTED)
+ * @NFTA_SET_ID: uniquely identifies a set in a transaction (NLA_U32)
  */
 enum nft_set_attributes {
         NFTA_SET_UNSPEC,
@@ -231,6 +257,9 @@ enum nft_set_attributes {
         NFTA_SET_KEY_LEN,
         NFTA_SET_DATA_TYPE,
         NFTA_SET_DATA_LEN,
+        NFTA_SET_POLICY,
+        NFTA_SET_DESC,
+        NFTA_SET_ID,
         __NFTA_SET_MAX
 };
 #define NFTA_SET_MAX            (__NFTA_SET_MAX - 1)
@@ -266,12 +295,14 @@ enum nft_set_elem_attributes {
  * @NFTA_SET_ELEM_LIST_TABLE: table of the set to be changed (NLA_STRING)
  * @NFTA_SET_ELEM_LIST_SET: name of the set to be changed (NLA_STRING)
  * @NFTA_SET_ELEM_LIST_ELEMENTS: list of set elements (NLA_NESTED: nft_set_elem_attributes)
+ * @NFTA_SET_ELEM_LIST_SET_ID: uniquely identifies a set in a transaction (NLA_U32)
  */
 enum nft_set_elem_list_attributes {
         NFTA_SET_ELEM_LIST_UNSPEC,
         NFTA_SET_ELEM_LIST_TABLE,
         NFTA_SET_ELEM_LIST_SET,
         NFTA_SET_ELEM_LIST_ELEMENTS,
+        NFTA_SET_ELEM_LIST_SET_ID,
         __NFTA_SET_ELEM_LIST_MAX
 };
 #define NFTA_SET_ELEM_LIST_MAX  (__NFTA_SET_ELEM_LIST_MAX - 1)
@@ -457,12 +488,14 @@ enum nft_cmp_attributes {
  * @NFTA_LOOKUP_SET: name of the set where to look for (NLA_STRING)
  * @NFTA_LOOKUP_SREG: source register of the data to look for (NLA_U32: nft_registers)
  * @NFTA_LOOKUP_DREG: destination register (NLA_U32: nft_registers)
+ * @NFTA_LOOKUP_SET_ID: uniquely identifies a set in a transaction (NLA_U32)
  */
 enum nft_lookup_attributes {
         NFTA_LOOKUP_UNSPEC,
         NFTA_LOOKUP_SET,
         NFTA_LOOKUP_SREG,
         NFTA_LOOKUP_DREG,
+        NFTA_LOOKUP_SET_ID,
         __NFTA_LOOKUP_MAX
 };
 #define NFTA_LOOKUP_MAX         (__NFTA_LOOKUP_MAX - 1)
@@ -536,6 +569,8 @@ enum nft_exthdr_attributes {
  * @NFT_META_SECMARK: packet secmark (skb->secmark)
  * @NFT_META_NFPROTO: netfilter protocol
  * @NFT_META_L4PROTO: layer 4 protocol number
+ * @NFT_META_BRI_IIFNAME: packet input bridge interface name
+ * @NFT_META_BRI_OIFNAME: packet output bridge interface name
  */
 enum nft_meta_keys {
         NFT_META_LEN,
@@ -555,6 +590,8 @@ enum nft_meta_keys {
         NFT_META_SECMARK,
         NFT_META_NFPROTO,
         NFT_META_L4PROTO,
+        NFT_META_BRI_IIFNAME,
+        NFT_META_BRI_OIFNAME,
 };
 
 /**
diff --git a/include/uapi/linux/netfilter/nfnetlink.h b/include/uapi/linux/netfilter/nfnetlink.h
index 596ddd45253c..354a7e5e50f2 100644
--- a/include/uapi/linux/netfilter/nfnetlink.h
+++ b/include/uapi/linux/netfilter/nfnetlink.h
@@ -20,6 +20,8 @@ enum nfnetlink_groups {
 #define NFNLGRP_CONNTRACK_EXP_DESTROY   NFNLGRP_CONNTRACK_EXP_DESTROY
         NFNLGRP_NFTABLES,
 #define NFNLGRP_NFTABLES                NFNLGRP_NFTABLES
+        NFNLGRP_ACCT_QUOTA,
+#define NFNLGRP_ACCT_QUOTA              NFNLGRP_ACCT_QUOTA
         __NFNLGRP_MAX,
 };
 #define NFNLGRP_MAX     (__NFNLGRP_MAX - 1)
diff --git a/include/uapi/linux/netfilter/nfnetlink_acct.h b/include/uapi/linux/netfilter/nfnetlink_acct.h
index c7b6269e760b..51404ec19022 100644
--- a/include/uapi/linux/netfilter/nfnetlink_acct.h
+++ b/include/uapi/linux/netfilter/nfnetlink_acct.h
@@ -10,15 +10,24 @@ enum nfnl_acct_msg_types {
         NFNL_MSG_ACCT_GET,
         NFNL_MSG_ACCT_GET_CTRZERO,
         NFNL_MSG_ACCT_DEL,
+        NFNL_MSG_ACCT_OVERQUOTA,
         NFNL_MSG_ACCT_MAX
 };
 
+enum nfnl_acct_flags {
+        NFACCT_F_QUOTA_PKTS     = (1 << 0),
+        NFACCT_F_QUOTA_BYTES    = (1 << 1),
+        NFACCT_F_OVERQUOTA      = (1 << 2), /* can't be set from userspace */
+};
+
 enum nfnl_acct_type {
         NFACCT_UNSPEC,
         NFACCT_NAME,
         NFACCT_PKTS,
         NFACCT_BYTES,
         NFACCT_USE,
+        NFACCT_FLAGS,
+        NFACCT_QUOTA,
         __NFACCT_MAX
 };
 #define NFACCT_MAX (__NFACCT_MAX - 1)
diff --git a/include/uapi/linux/nfc.h b/include/uapi/linux/nfc.h
index 9789dc95b6a8..9b19b4461928 100644
--- a/include/uapi/linux/nfc.h
+++ b/include/uapi/linux/nfc.h
@@ -273,11 +273,19 @@ struct sockaddr_nfc_llcp {
  * First byte is the adapter index
  * Second byte contains flags
  *  - 0x01 - Direction (0=RX, 1=TX)
- *  - 0x02-0x80 - Reserved
+ *  - 0x02-0x04 - Payload type (000=LLCP, 001=NCI, 010=HCI, 011=Digital,
+ *                              100=Proprietary)
+ *  - 0x05-0x80 - Reserved
  **/
-#define NFC_LLCP_RAW_HEADER_SIZE        2
-#define NFC_LLCP_DIRECTION_RX           0x00
-#define NFC_LLCP_DIRECTION_TX           0x01
+#define NFC_RAW_HEADER_SIZE     2
+#define NFC_DIRECTION_RX                0x00
+#define NFC_DIRECTION_TX                0x01
+
+#define RAW_PAYLOAD_LLCP 0
+#define RAW_PAYLOAD_NCI 1
+#define RAW_PAYLOAD_HCI 2
+#define RAW_PAYLOAD_DIGITAL     3
+#define RAW_PAYLOAD_PROPRIETARY 4
 
 /* socket option names */
 #define NFC_LLCP_RW             0
diff --git a/include/uapi/linux/nl80211.h b/include/uapi/linux/nl80211.h
index 194c1eab04d8..be9519b52bb1 100644
--- a/include/uapi/linux/nl80211.h
+++ b/include/uapi/linux/nl80211.h
@@ -503,6 +503,9 @@
  *      TX status event pertaining to the TX request.
  *      %NL80211_ATTR_TX_NO_CCK_RATE is used to decide whether to send the
  *      management frames at CCK rate or not in 2GHz band.
+ *      %NL80211_ATTR_CSA_C_OFFSETS_TX is an array of offsets to CSA
+ *      counters which will be updated to the current value. This attribute
+ *      is used during CSA period.
  * @NL80211_CMD_FRAME_WAIT_CANCEL: When an off-channel TX was requested, this
  *      command may be used with the corresponding cookie to cancel the wait
  *      time if it is known that it is no longer necessary.
@@ -1525,10 +1528,10 @@ enum nl80211_commands {
  *      operation).
  * @NL80211_ATTR_CSA_IES: Nested set of attributes containing the IE information
  *      for the time while performing a channel switch.
- * @NL80211_ATTR_CSA_C_OFF_BEACON: Offset of the channel switch counter
- *      field in the beacons tail (%NL80211_ATTR_BEACON_TAIL).
- * @NL80211_ATTR_CSA_C_OFF_PRESP: Offset of the channel switch counter
- *      field in the probe response (%NL80211_ATTR_PROBE_RESP).
+ * @NL80211_ATTR_CSA_C_OFF_BEACON: An array of offsets (u16) to the channel
+ *      switch counters in the beacons tail (%NL80211_ATTR_BEACON_TAIL).
+ * @NL80211_ATTR_CSA_C_OFF_PRESP: An array of offsets (u16) to the channel
+ *      switch counters in the probe response (%NL80211_ATTR_PROBE_RESP).
  *
  * @NL80211_ATTR_RXMGMT_FLAGS: flags for nl80211_send_mgmt(), u32.
  *      As specified in the &enum nl80211_rxmgmt_flags.
@@ -1576,9 +1579,18 @@ enum nl80211_commands {
  *      advertise values that cannot always be met. In such cases, an attempt
  *      to add a new station entry with @NL80211_CMD_NEW_STATION may fail.
  *
+ * @NL80211_ATTR_CSA_C_OFFSETS_TX: An array of csa counter offsets (u16) which
+ *      should be updated when the frame is transmitted.
+ * @NL80211_ATTR_MAX_CSA_COUNTERS: U8 attribute used to advertise the maximum
+ *      supported number of csa counters.
+ *
  * @NL80211_ATTR_TDLS_PEER_CAPABILITY: flags for TDLS peer capabilities, u32.
  *      As specified in the &enum nl80211_tdls_peer_capability.
  *
+ * @NL80211_ATTR_IFACE_SOCKET_OWNER: flag attribute, if set during interface
+ *      creation then the new interface will be owned by the netlink socket
+ *      that created it and will be destroyed when the socket is closed
+ *
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
  */
@@ -1914,6 +1926,11 @@ enum nl80211_attrs {
 
         NL80211_ATTR_TDLS_PEER_CAPABILITY,
 
+        NL80211_ATTR_IFACE_SOCKET_OWNER,
+
+        NL80211_ATTR_CSA_C_OFFSETS_TX,
+        NL80211_ATTR_MAX_CSA_COUNTERS,
+
         /* add attributes here, update the policy in nl80211.c */
 
         __NL80211_ATTR_AFTER_LAST,
@@ -2182,6 +2199,8 @@ enum nl80211_sta_bss_param {
  *      Contains a nested array of signal strength attributes (u8, dBm)
  * @NL80211_STA_INFO_CHAIN_SIGNAL_AVG: per-chain signal strength average
  *      Same format as NL80211_STA_INFO_CHAIN_SIGNAL.
+ * @NL80211_STA_EXPECTED_THROUGHPUT: expected throughput considering also the
+ *      802.11 header (u32, kbps)
  * @__NL80211_STA_INFO_AFTER_LAST: internal
  * @NL80211_STA_INFO_MAX: highest possible station info attribute
  */
@@ -2213,6 +2232,7 @@ enum nl80211_sta_info {
         NL80211_STA_INFO_TX_BYTES64,
         NL80211_STA_INFO_CHAIN_SIGNAL,
         NL80211_STA_INFO_CHAIN_SIGNAL_AVG,
+        NL80211_STA_INFO_EXPECTED_THROUGHPUT,
 
         /* keep last */
         __NL80211_STA_INFO_AFTER_LAST,
@@ -2336,9 +2356,34 @@ enum nl80211_band_attr {
  *      using this channel as the primary or any of the secondary channels
  *      isn't possible
  * @NL80211_FREQUENCY_ATTR_DFS_CAC_TIME: DFS CAC time in milliseconds.
+ * @NL80211_FREQUENCY_ATTR_INDOOR_ONLY: Only indoor use is permitted on this
+ *      channel. A channel that has the INDOOR_ONLY attribute can only be
+ *      used when there is a clear assessment that the device is operating in
+ *      an indoor surroundings, i.e., it is connected to AC power (and not
+ *      through portable DC inverters) or is under the control of a master
+ *      that is acting as an AP and is connected to AC power.
+ * @NL80211_FREQUENCY_ATTR_GO_CONCURRENT: GO operation is allowed on this
+ *      channel if it's connected concurrently to a BSS on the same channel on
+ *      the 2 GHz band or to a channel in the same UNII band (on the 5 GHz
+ *      band), and IEEE80211_CHAN_RADAR is not set. Instantiating a GO on a
+ *      channel that has the GO_CONCURRENT attribute set can be done when there
+ *      is a clear assessment that the device is operating under the guidance of
+ *      an authorized master, i.e., setting up a GO while the device is also
+ *      connected to an AP with DFS and radar detection on the UNII band (it is
+ *      up to user-space, i.e., wpa_supplicant to perform the required
+ *      verifications)
+ * @NL80211_FREQUENCY_ATTR_NO_20MHZ: 20 MHz operation is not allowed
+ *      on this channel in current regulatory domain.
+ * @NL80211_FREQUENCY_ATTR_NO_10MHZ: 10 MHz operation is not allowed
+ *      on this channel in current regulatory domain.
  * @NL80211_FREQUENCY_ATTR_MAX: highest frequency attribute number
  *      currently defined
  * @__NL80211_FREQUENCY_ATTR_AFTER_LAST: internal use
+ *
+ * See https://apps.fcc.gov/eas/comments/GetPublishedDocument.html?id=327&tn=528122
+ * for more information on the FCC description of the relaxations allowed
+ * by NL80211_FREQUENCY_ATTR_INDOOR_ONLY and
+ * NL80211_FREQUENCY_ATTR_GO_CONCURRENT.
  */
 enum nl80211_frequency_attr {
         __NL80211_FREQUENCY_ATTR_INVALID,
@@ -2355,6 +2400,10 @@ enum nl80211_frequency_attr {
         NL80211_FREQUENCY_ATTR_NO_80MHZ,
         NL80211_FREQUENCY_ATTR_NO_160MHZ,
         NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
+        NL80211_FREQUENCY_ATTR_INDOOR_ONLY,
+        NL80211_FREQUENCY_ATTR_GO_CONCURRENT,
+        NL80211_FREQUENCY_ATTR_NO_20MHZ,
+        NL80211_FREQUENCY_ATTR_NO_10MHZ,
 
         /* keep last */
         __NL80211_FREQUENCY_ATTR_AFTER_LAST,
@@ -2573,10 +2622,13 @@ enum nl80211_dfs_regions {
  *      present has been registered with the wireless core that
  *      has listed NL80211_FEATURE_CELL_BASE_REG_HINTS as a
  *      supported feature.
+ * @NL80211_USER_REG_HINT_INDOOR: a user sent an hint indicating that the
+ *      platform is operating in an indoor environment.
  */
 enum nl80211_user_reg_hint_type {
         NL80211_USER_REG_HINT_USER      = 0,
         NL80211_USER_REG_HINT_CELL_BASE = 1,
+        NL80211_USER_REG_HINT_INDOOR    = 2,
 };
 
 /**
@@ -3650,6 +3702,8 @@ enum nl80211_iface_limit_attrs {
  *      different channels may be used within this group.
  * @NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS: u32 attribute containing the bitmap
  *      of supported channel widths for radar detection.
+ * @NL80211_IFACE_COMB_RADAR_DETECT_REGIONS: u32 attribute containing the bitmap
+ *      of supported regulatory regions for radar detection.
  * @NUM_NL80211_IFACE_COMB: number of attributes
  * @MAX_NL80211_IFACE_COMB: highest attribute number
  *
@@ -3683,6 +3737,7 @@ enum nl80211_if_combination_attrs {
         NL80211_IFACE_COMB_STA_AP_BI_MATCH,
         NL80211_IFACE_COMB_NUM_CHANNELS,
         NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
+        NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
 
         /* keep last */
         NUM_NL80211_IFACE_COMB,
@@ -3893,6 +3948,9 @@ enum nl80211_ap_sme_features {
  *      interface. An active monitor interface behaves like a normal monitor
  *      interface, but gets added to the driver. It ensures that incoming
  *      unicast packets directed at the configured interface address get ACKed.
+ * @NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE: This driver supports dynamic
+ *      channel bandwidth change (e.g., HT 20 <-> 40 MHz channel) during the
+ *      lifetime of a BSS.
  */
 enum nl80211_feature_flags {
         NL80211_FEATURE_SK_TX_STATUS                    = 1 << 0,
@@ -3913,6 +3971,7 @@ enum nl80211_feature_flags {
         NL80211_FEATURE_FULL_AP_CLIENT_STATE            = 1 << 15,
         NL80211_FEATURE_USERSPACE_MPM                   = 1 << 16,
         NL80211_FEATURE_ACTIVE_MONITOR                  = 1 << 17,
+        NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE       = 1 << 18,
 };
 
 /**
diff --git a/include/uapi/linux/openvswitch.h b/include/uapi/linux/openvswitch.h
index 970553cbbc8e..0b979ee4bfc0 100644
--- a/include/uapi/linux/openvswitch.h
+++ b/include/uapi/linux/openvswitch.h
@@ -395,7 +395,9 @@ struct ovs_key_nd {
  * @OVS_FLOW_ATTR_ACTIONS: Nested %OVS_ACTION_ATTR_* attributes specifying
  * the actions to take for packets that match the key.  Always present in
  * notifications.  Required for %OVS_FLOW_CMD_NEW requests, optional for
- * %OVS_FLOW_CMD_SET requests.
+ * %OVS_FLOW_CMD_SET requests.  An %OVS_FLOW_CMD_SET without
+ * %OVS_FLOW_ATTR_ACTIONS will not modify the actions.  To clear the actions,
+ * an %OVS_FLOW_ATTR_ACTIONS without any nested attributes must be given.
  * @OVS_FLOW_ATTR_STATS: &struct ovs_flow_stats giving statistics for this
  * flow.  Present in notifications if the stats would be nonzero.  Ignored in
  * requests.
diff --git a/include/uapi/linux/tipc.h b/include/uapi/linux/tipc.h
index 852373d27dbb..6f71b9b41595 100644
--- a/include/uapi/linux/tipc.h
+++ b/include/uapi/linux/tipc.h
@@ -38,6 +38,7 @@
 #define _LINUX_TIPC_H_
 
 #include <linux/types.h>
+#include <linux/sockios.h>
 
 /*
  * TIPC addressing primitives
@@ -87,6 +88,7 @@ static inline unsigned int tipc_node(__u32 addr)
 
 #define TIPC_CFG_SRV            0       /* configuration service name type */
 #define TIPC_TOP_SRV            1       /* topology service name type */
+#define TIPC_LINK_STATE         2       /* link state name type */
 #define TIPC_RESERVED_TYPES     64      /* lowest user-publishable name type */
 
 /*
@@ -206,4 +208,25 @@ struct sockaddr_tipc {
 #define TIPC_NODE_RECVQ_DEPTH   131     /* Default: none (read only) */
 #define TIPC_SOCK_RECVQ_DEPTH   132     /* Default: none (read only) */
 
+/*
+ * Maximum sizes of TIPC bearer-related names (including terminating NULL)
+ * The string formatting for each name element is:
+ * media: media
+ * interface: media:interface name
+ * link: Z.C.N:interface-Z.C.N:interface
+ *
+ */
+
+#define TIPC_MAX_MEDIA_NAME     16
+#define TIPC_MAX_IF_NAME        16
+#define TIPC_MAX_BEARER_NAME    32
+#define TIPC_MAX_LINK_NAME      60
+
+#define SIOCGETLINKNAME         SIOCPROTOPRIVATE
+
+struct tipc_sioc_ln_req {
+        __u32 peer;
+        __u32 bearer_id;
+        char linkname[TIPC_MAX_LINK_NAME];
+};
 #endif
diff --git a/include/uapi/linux/tipc_config.h b/include/uapi/linux/tipc_config.h
index 6b0bff09b3a7..41a76acbb305 100644
--- a/include/uapi/linux/tipc_config.h
+++ b/include/uapi/linux/tipc_config.h
@@ -39,6 +39,7 @@
 
 #include <linux/types.h>
 #include <linux/string.h>
+#include <linux/tipc.h>
 #include <asm/byteorder.h>
 
 #ifndef __KERNEL__
@@ -155,15 +156,6 @@
 #define TIPC_TLV_PORT_REF       26      /* 32-bit port reference */
 
 /*
- * Maximum sizes of TIPC bearer-related names (including terminating NUL)
- */
-
-#define TIPC_MAX_MEDIA_NAME     16      /* format = media */
-#define TIPC_MAX_IF_NAME        16      /* format = interface */
-#define TIPC_MAX_BEARER_NAME    32      /* format = media:interface */
-#define TIPC_MAX_LINK_NAME      60      /* format = Z.C.N:interface-Z.C.N:interface */
-
-/*
  * Link priority limits (min, default, max, media default)
  */
 
diff --git a/include/uapi/linux/udp.h b/include/uapi/linux/udp.h
index e2bcfd75a30d..16574ea18f0c 100644
--- a/include/uapi/linux/udp.h
+++ b/include/uapi/linux/udp.h
@@ -29,6 +29,8 @@ struct udphdr {
 /* UDP socket options */
 #define UDP_CORK        1       /* Never send partially complete segments */
 #define UDP_ENCAP       100     /* Set the socket to accept encapsulated packets */
+#define UDP_NO_CHECK6_TX 101    /* Disable sending checksum for UDP6X */
+#define UDP_NO_CHECK6_RX 102    /* Disable accpeting checksum for UDP6 */
 
 /* UDP encapsulation types */
 #define UDP_ENCAP_ESPINUDP_NON_IKE      1 /* draft-ietf-ipsec-nat-t-ike-00/01 */
diff --git a/include/xen/interface/io/netif.h b/include/xen/interface/io/netif.h
index c50061db6098..70054cc0708d 100644
--- a/include/xen/interface/io/netif.h
+++ b/include/xen/interface/io/netif.h
@@ -51,6 +51,59 @@
  */
 
 /*
+ * Multiple transmit and receive queues:
+ * If supported, the backend will write the key "multi-queue-max-queues" to
+ * the directory for that vif, and set its value to the maximum supported
+ * number of queues.
+ * Frontends that are aware of this feature and wish to use it can write the
+ * key "multi-queue-num-queues", set to the number they wish to use, which
+ * must be greater than zero, and no more than the value reported by the backend
+ * in "multi-queue-max-queues".
+ *
+ * Queues replicate the shared rings and event channels.
+ * "feature-split-event-channels" may optionally be used when using
+ * multiple queues, but is not mandatory.
+ *
+ * Each queue consists of one shared ring pair, i.e. there must be the same
+ * number of tx and rx rings.
+ *
+ * For frontends requesting just one queue, the usual event-channel and
+ * ring-ref keys are written as before, simplifying the backend processing
+ * to avoid distinguishing between a frontend that doesn't understand the
+ * multi-queue feature, and one that does, but requested only one queue.
+ *
+ * Frontends requesting two or more queues must not write the toplevel
+ * event-channel (or event-channel-{tx,rx}) and {tx,rx}-ring-ref keys,
+ * instead writing those keys under sub-keys having the name "queue-N" where
+ * N is the integer ID of the queue for which those keys belong. Queues
+ * are indexed from zero. For example, a frontend with two queues and split
+ * event channels must write the following set of queue-related keys:
+ *
+ * /local/domain/1/device/vif/0/multi-queue-num-queues = "2"
+ * /local/domain/1/device/vif/0/queue-0 = ""
+ * /local/domain/1/device/vif/0/queue-0/tx-ring-ref = "<ring-ref-tx0>"
+ * /local/domain/1/device/vif/0/queue-0/rx-ring-ref = "<ring-ref-rx0>"
+ * /local/domain/1/device/vif/0/queue-0/event-channel-tx = "<evtchn-tx0>"
+ * /local/domain/1/device/vif/0/queue-0/event-channel-rx = "<evtchn-rx0>"
+ * /local/domain/1/device/vif/0/queue-1 = ""
+ * /local/domain/1/device/vif/0/queue-1/tx-ring-ref = "<ring-ref-tx1>"
+ * /local/domain/1/device/vif/0/queue-1/rx-ring-ref = "<ring-ref-rx1"
+ * /local/domain/1/device/vif/0/queue-1/event-channel-tx = "<evtchn-tx1>"
+ * /local/domain/1/device/vif/0/queue-1/event-channel-rx = "<evtchn-rx1>"
+ *
+ * If there is any inconsistency in the XenStore data, the backend may
+ * choose not to connect any queues, instead treating the request as an
+ * error. This includes scenarios where more (or fewer) queues were
+ * requested than the frontend provided details for.
+ *
+ * Mapping of packets to queues is considered to be a function of the
+ * transmitting system (backend or frontend) and is not negotiated
+ * between the two. Guests are free to transmit packets on any queue
+ * they choose, provided it has been set up correctly. Guests must be
+ * prepared to receive packets on any queue they have requested be set up.
+ */
+
+/*
  * "feature-no-csum-offload" should be used to turn IPv4 TCP/UDP checksum
  * offload off or on. If it is missing then the feature is assumed to be on.
  * "feature-ipv6-csum-offload" should be used to turn IPv6 TCP/UDP checksum