add watchdog support for cubox, inlude weim by default

6 files changed, 1978 insertions, 141 deletions

diff --git a/target/linux/config/Config.in.audio b/target/linux/config/Config.in.audio
index 6ba4f4842..7813c1800 100644
--- a/target/linux/config/Config.in.audio
+++ b/target/linux/config/Config.in.audio
@@ -16,6 +16,9 @@ config ADK_KERNEL_SND_ARM
 config ADK_KERNEL_SND_SOC_GENERIC_DMAENGINE_PCM
 	boolean
 
+config ADK_KERNEL_SND_DMAENGINE_PCM
+	tristate
+
 config ADK_KERNEL_SND_SOC_SPDIF
 	tristate
 
@@ -175,7 +178,8 @@ config ADK_KERNEL_SND_IMX_SOC
 	select ADK_KERNEL_SND_SOC
 	select ADK_KERNEL_SND_COMPRESS
 	select ADK_KERNEL_SND_PCM_DMAENGINE if !ADK_KERNEL_VERSION_3_10_30
-	select ADK_KERNEL_SND_SOC_GENERIC_DMAENGINE_PCM if ADK_KERNEL_VERSION_3_10_30
+	select ADK_KERNEL_SND_SOC_GENERIC_DMAENGINE_PCM
+	select ADK_KERNEL_SND_DMAENGINE_PCM
 	select ADK_KERNEL_SND_SOC_FSL_SPDIF if ADK_KERNEL_VERSION_3_10_30
 	select ADK_KERNEL_SND_SOC_IMX_PCM_DMA
 	select ADK_KERNEL_SND_SOC_IMX_HDMI_DMA
@@ -185,7 +189,7 @@ config ADK_KERNEL_SND_IMX_SOC
 	select ADK_KERNEL_REGMAP_SPI
 	select ADK_KERNEL_REGMAP_I2C
 	depends on ADK_TARGET_SYSTEM_CUBOX_I
-	default m if ADK_TARGET_SYSTEM_CUBOX_I && !ADK_KERNEL_VERSION_3_14
+	default m if ADK_TARGET_SYSTEM_CUBOX_I
 	default n
 
 endmenu
diff --git a/target/linux/config/Config.in.misc b/target/linux/config/Config.in.misc
index 463a8f369..41e8edc0c 100644
--- a/target/linux/config/Config.in.misc
+++ b/target/linux/config/Config.in.misc
@@ -12,6 +12,12 @@ config ADK_KERNEL_KEYS
 config ADK_KERNEL_SBUS
 	boolean
 
+config ADK_KERNEL_IMX_WEIM
+	boolean
+	depends on ADK_TARGET_SYSTEM_CUBOX_I
+	default y if ADK_TARGET_SYSTEM_CUBOX_I
+	default n
+
 menu "Miscellaneous devices support"
 
 source "target/linux/config/Config.in.rtc"
diff --git a/target/linux/config/Config.in.watchdog b/target/linux/config/Config.in.watchdog
index d8cc5932e..1b9d183cc 100644
--- a/target/linux/config/Config.in.watchdog
+++ b/target/linux/config/Config.in.watchdog
@@ -15,6 +15,16 @@ config ADK_KERNEL_CS5535_CLOCK_EVENT_SRC
 
 menu "Watchdog driver support"
 
+config ADK_KERNEL_IMX2_WDT
+	prompt "Cubox-i Hardware Watchdog"
+	boolean
+	select ADK_KERNEL_WATCHDOG
+	depends on ADK_TARGET_SYSTEM_CUBOX_I
+	default y if ADK_TARGET_SYSTEM_CUBOX_I
+	default n
+	help
+	  Watchdog driver for Cubox-i
+
 config ADK_KERNEL_SCx200_WDT
 	prompt "Natsemi Hardware Watchdog" 
 	boolean
diff --git a/target/linux/patches/3.15-rc7/yaffs2.patch b/target/linux/patches/3.15-rc7/patch-yaffs2
index bb244c7ca..bb244c7ca 100644
--- a/target/linux/patches/3.15-rc7/yaffs2.patch
+++ b/target/linux/patches/3.15-rc7/patch-yaffs2
diff --git a/target/linux/patches/3.15-rc7/tcp-fastopen.patch b/target/linux/patches/3.15-rc7/tcp-fastopen.patch
index 19e1ee2a4..fc1d076ac 100644
--- a/target/linux/patches/3.15-rc7/tcp-fastopen.patch
+++ b/target/linux/patches/3.15-rc7/tcp-fastopen.patch
@@ -1,253 +1,2082 @@
-https://lkml.org/lkml/2014/5/5/674
-Andi Kleen <ak@linux.intel.com>
-
-diff -Nur linux-3.15-rc7/include/linux/tcp.h linux-3.15-rc7.orig/include/linux/tcp.h
---- linux-3.15-rc7/include/linux/tcp.h	2014-05-30 10:01:47.000000000 +0200
-+++ linux-3.15-rc7.orig/include/linux/tcp.h	2014-05-26 01:06:00.000000000 +0200
-@@ -359,9 +359,6 @@
+diff -Nur linux-3.15-rc7.orig/include/linux/tcp.h linux-3.15-rc7/include/linux/tcp.h
+--- linux-3.15-rc7.orig/include/linux/tcp.h	2014-05-26 01:06:00.000000000 +0200
++++ linux-3.15-rc7/include/linux/tcp.h	2014-05-31 22:42:49.024605293 +0200
+@@ -359,6 +359,9 @@
  	return (struct tcp_timewait_sock *)sk;
  }
  
--extern void tcp_sock_destruct(struct sock *sk);
--
--#ifdef CONFIG_TCP_FASTOPEN
++extern void tcp_sock_destruct(struct sock *sk);
++
++#ifdef CONFIG_TCP_FASTOPEN
  static inline bool tcp_passive_fastopen(const struct sock *sk)
  {
  	return (sk->sk_state == TCP_SYN_RECV &&
-@@ -373,6 +370,8 @@
+@@ -370,8 +373,6 @@
  	return foc->len != -1;
  }
  
-+extern void tcp_sock_destruct(struct sock *sk);
-+
+-extern void tcp_sock_destruct(struct sock *sk);
+-
  static inline int fastopen_init_queue(struct sock *sk, int backlog)
  {
  	struct request_sock_queue *queue =
-@@ -392,13 +391,4 @@
+@@ -391,4 +392,13 @@
  	return 0;
  }
  
--#else
--static inline bool tcp_passive_fastopen(const struct sock *sk)
--{ return false; }
--static inline bool fastopen_cookie_present(struct tcp_fastopen_cookie *foc)
--{ return false; }
--static inline int fastopen_init_queue(struct sock *sk, int backlog)
--{ return 0; }
--#endif
--
++#else
++static inline bool tcp_passive_fastopen(const struct sock *sk)
++{ return false; }
++static inline bool fastopen_cookie_present(struct tcp_fastopen_cookie *foc)
++{ return false; }
++static inline int fastopen_init_queue(struct sock *sk, int backlog)
++{ return 0; }
++#endif
++
  #endif	/* _LINUX_TCP_H */
-diff -Nur linux-3.15-rc7/include/net/request_sock.h linux-3.15-rc7.orig/include/net/request_sock.h
---- linux-3.15-rc7/include/net/request_sock.h	2014-05-30 10:01:47.000000000 +0200
-+++ linux-3.15-rc7.orig/include/net/request_sock.h	2014-05-26 01:06:00.000000000 +0200
-@@ -168,13 +168,8 @@
+diff -Nur linux-3.15-rc7.orig/include/net/request_sock.h linux-3.15-rc7/include/net/request_sock.h
+--- linux-3.15-rc7.orig/include/net/request_sock.h	2014-05-26 01:06:00.000000000 +0200
++++ linux-3.15-rc7/include/net/request_sock.h	2014-05-31 22:42:49.024605293 +0200
+@@ -168,8 +168,13 @@
  
  void __reqsk_queue_destroy(struct request_sock_queue *queue);
  void reqsk_queue_destroy(struct request_sock_queue *queue);
--#ifdef CONFIG_TCP_FASTOPEN
++#ifdef CONFIG_TCP_FASTOPEN
  void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
  			   bool reset);
--#else
--static inline void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
--			   bool reset) {}
--#endif
++#else
++static inline void reqsk_fastopen_remove(struct sock *sk, struct request_sock *req,
++			   bool reset) {}
++#endif
  
  static inline struct request_sock *
  	reqsk_queue_yank_acceptq(struct request_sock_queue *queue)
-diff -Nur linux-3.15-rc7/include/net/tcp.h linux-3.15-rc7.orig/include/net/tcp.h
---- linux-3.15-rc7/include/net/tcp.h	2014-05-30 10:01:47.000000000 +0200
-+++ linux-3.15-rc7.orig/include/net/tcp.h	2014-05-26 01:06:00.000000000 +0200
-@@ -251,11 +251,7 @@
+diff -Nur linux-3.15-rc7.orig/include/net/tcp.h linux-3.15-rc7/include/net/tcp.h
+--- linux-3.15-rc7.orig/include/net/tcp.h	2014-05-26 01:06:00.000000000 +0200
++++ linux-3.15-rc7/include/net/tcp.h	2014-05-31 22:42:49.028605326 +0200
+@@ -251,7 +251,11 @@
  extern int sysctl_tcp_retries2;
  extern int sysctl_tcp_orphan_retries;
  extern int sysctl_tcp_syncookies;
--#ifdef CONFIG_TCP_FASTOPEN
++#ifdef CONFIG_TCP_FASTOPEN
  extern int sysctl_tcp_fastopen;
--#else
--#define sysctl_tcp_fastopen 0
--#endif
++#else
++#define sysctl_tcp_fastopen 0
++#endif
  extern int sysctl_tcp_retrans_collapse;
  extern int sysctl_tcp_stdurg;
  extern int sysctl_tcp_rfc1337;
-@@ -1312,12 +1308,7 @@
+@@ -1308,7 +1312,12 @@
  	size_t				size;
  	int				copied;	/* queued in tcp_connect() */
  };
--
--#ifdef CONFIG_TCP_FASTOPEN
++
++#ifdef CONFIG_TCP_FASTOPEN
  void tcp_free_fastopen_req(struct tcp_sock *tp);
--#else
--static inline void tcp_free_fastopen_req(struct tcp_sock *tp) {}
--#endif
++#else
++static inline void tcp_free_fastopen_req(struct tcp_sock *tp) {}
++#endif
  
  extern struct tcp_fastopen_context __rcu *tcp_fastopen_ctx;
  int tcp_fastopen_reset_cipher(void *key, unsigned int len);
-diff -Nur linux-3.15-rc7/net/Kconfig linux-3.15-rc7.orig/net/Kconfig
---- linux-3.15-rc7/net/Kconfig	2014-05-30 10:01:47.000000000 +0200
-+++ linux-3.15-rc7.orig/net/Kconfig	2014-05-26 01:06:00.000000000 +0200
-@@ -53,8 +53,8 @@
- 
- config INET
- 	bool "TCP/IP networking"
--	select CRYPTO if TCP_FASTOPEN
--	select CRYPTO_AES if TCP_FASTOPEN
-+	select CRYPTO
-+	select CRYPTO_AES
- 	---help---
- 	  These are the protocols used on the Internet and on most local
- 	  Ethernets. It is highly recommended to say Y here (this will enlarge
-diff -Nur linux-3.15-rc7/net/core/request_sock.c linux-3.15-rc7.orig/net/core/request_sock.c
---- linux-3.15-rc7/net/core/request_sock.c	2014-05-30 10:01:47.000000000 +0200
-+++ linux-3.15-rc7.orig/net/core/request_sock.c	2014-05-26 01:06:00.000000000 +0200
-@@ -131,7 +131,6 @@
+diff -Nur linux-3.15-rc7.orig/include/net/tcp.h.orig linux-3.15-rc7/include/net/tcp.h.orig
+--- linux-3.15-rc7.orig/include/net/tcp.h.orig	1970-01-01 01:00:00.000000000 +0100
++++ linux-3.15-rc7/include/net/tcp.h.orig	2014-05-26 01:06:00.000000000 +0200
+@@ -0,0 +1,1600 @@
++/*
++ * INET		An implementation of the TCP/IP protocol suite for the LINUX
++ *		operating system.  INET is implemented using the  BSD Socket
++ *		interface as the means of communication with the user level.
++ *
++ *		Definitions for the TCP module.
++ *
++ * Version:	@(#)tcp.h	1.0.5	05/23/93
++ *
++ * Authors:	Ross Biro
++ *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
++ *
++ *		This program is free software; you can redistribute it and/or
++ *		modify it under the terms of the GNU General Public License
++ *		as published by the Free Software Foundation; either version
++ *		2 of the License, or (at your option) any later version.
++ */
++#ifndef _TCP_H
++#define _TCP_H
++
++#define FASTRETRANS_DEBUG 1
++
++#include <linux/list.h>
++#include <linux/tcp.h>
++#include <linux/bug.h>
++#include <linux/slab.h>
++#include <linux/cache.h>
++#include <linux/percpu.h>
++#include <linux/skbuff.h>
++#include <linux/dmaengine.h>
++#include <linux/crypto.h>
++#include <linux/cryptohash.h>
++#include <linux/kref.h>
++#include <linux/ktime.h>
++
++#include <net/inet_connection_sock.h>
++#include <net/inet_timewait_sock.h>
++#include <net/inet_hashtables.h>
++#include <net/checksum.h>
++#include <net/request_sock.h>
++#include <net/sock.h>
++#include <net/snmp.h>
++#include <net/ip.h>
++#include <net/tcp_states.h>
++#include <net/inet_ecn.h>
++#include <net/dst.h>
++
++#include <linux/seq_file.h>
++#include <linux/memcontrol.h>
++
++extern struct inet_hashinfo tcp_hashinfo;
++
++extern struct percpu_counter tcp_orphan_count;
++void tcp_time_wait(struct sock *sk, int state, int timeo);
++
++#define MAX_TCP_HEADER	(128 + MAX_HEADER)
++#define MAX_TCP_OPTION_SPACE 40
++
++/* 
++ * Never offer a window over 32767 without using window scaling. Some
++ * poor stacks do signed 16bit maths! 
++ */
++#define MAX_TCP_WINDOW		32767U
++
++/* Minimal accepted MSS. It is (60+60+8) - (20+20). */
++#define TCP_MIN_MSS		88U
++
++/* The least MTU to use for probing */
++#define TCP_BASE_MSS		512
++
++/* After receiving this amount of duplicate ACKs fast retransmit starts. */
++#define TCP_FASTRETRANS_THRESH 3
++
++/* Maximal reordering. */
++#define TCP_MAX_REORDERING	127
++
++/* Maximal number of ACKs sent quickly to accelerate slow-start. */
++#define TCP_MAX_QUICKACKS	16U
++
++/* urg_data states */
++#define TCP_URG_VALID	0x0100
++#define TCP_URG_NOTYET	0x0200
++#define TCP_URG_READ	0x0400
++
++#define TCP_RETR1	3	/*
++				 * This is how many retries it does before it
++				 * tries to figure out if the gateway is
++				 * down. Minimal RFC value is 3; it corresponds
++				 * to ~3sec-8min depending on RTO.
++				 */
++
++#define TCP_RETR2	15	/*
++				 * This should take at least
++				 * 90 minutes to time out.
++				 * RFC1122 says that the limit is 100 sec.
++				 * 15 is ~13-30min depending on RTO.
++				 */
++
++#define TCP_SYN_RETRIES	 6	/* This is how many retries are done
++				 * when active opening a connection.
++				 * RFC1122 says the minimum retry MUST
++				 * be at least 180secs.  Nevertheless
++				 * this value is corresponding to
++				 * 63secs of retransmission with the
++				 * current initial RTO.
++				 */
++
++#define TCP_SYNACK_RETRIES 5	/* This is how may retries are done
++				 * when passive opening a connection.
++				 * This is corresponding to 31secs of
++				 * retransmission with the current
++				 * initial RTO.
++				 */
++
++#define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
++				  * state, about 60 seconds	*/
++#define TCP_FIN_TIMEOUT	TCP_TIMEWAIT_LEN
++                                 /* BSD style FIN_WAIT2 deadlock breaker.
++				  * It used to be 3min, new value is 60sec,
++				  * to combine FIN-WAIT-2 timeout with
++				  * TIME-WAIT timer.
++				  */
++
++#define TCP_DELACK_MAX	((unsigned)(HZ/5))	/* maximal time to delay before sending an ACK */
++#if HZ >= 100
++#define TCP_DELACK_MIN	((unsigned)(HZ/25))	/* minimal time to delay before sending an ACK */
++#define TCP_ATO_MIN	((unsigned)(HZ/25))
++#else
++#define TCP_DELACK_MIN	4U
++#define TCP_ATO_MIN	4U
++#endif
++#define TCP_RTO_MAX	((unsigned)(120*HZ))
++#define TCP_RTO_MIN	((unsigned)(HZ/5))
++#define TCP_TIMEOUT_INIT ((unsigned)(1*HZ))	/* RFC6298 2.1 initial RTO value	*/
++#define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ))	/* RFC 1122 initial RTO value, now
++						 * used as a fallback RTO for the
++						 * initial data transmission if no
++						 * valid RTT sample has been acquired,
++						 * most likely due to retrans in 3WHS.
++						 */
++
++#define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
++					                 * for local resources.
++					                 */
++
++#define TCP_KEEPALIVE_TIME	(120*60*HZ)	/* two hours */
++#define TCP_KEEPALIVE_PROBES	9		/* Max of 9 keepalive probes	*/
++#define TCP_KEEPALIVE_INTVL	(75*HZ)
++
++#define MAX_TCP_KEEPIDLE	32767
++#define MAX_TCP_KEEPINTVL	32767
++#define MAX_TCP_KEEPCNT		127
++#define MAX_TCP_SYNCNT		127
++
++#define TCP_SYNQ_INTERVAL	(HZ/5)	/* Period of SYNACK timer */
++
++#define TCP_PAWS_24DAYS	(60 * 60 * 24 * 24)
++#define TCP_PAWS_MSL	60		/* Per-host timestamps are invalidated
++					 * after this time. It should be equal
++					 * (or greater than) TCP_TIMEWAIT_LEN
++					 * to provide reliability equal to one
++					 * provided by timewait state.
++					 */
++#define TCP_PAWS_WINDOW	1		/* Replay window for per-host
++					 * timestamps. It must be less than
++					 * minimal timewait lifetime.
++					 */
++/*
++ *	TCP option
++ */
++ 
++#define TCPOPT_NOP		1	/* Padding */
++#define TCPOPT_EOL		0	/* End of options */
++#define TCPOPT_MSS		2	/* Segment size negotiating */
++#define TCPOPT_WINDOW		3	/* Window scaling */
++#define TCPOPT_SACK_PERM        4       /* SACK Permitted */
++#define TCPOPT_SACK             5       /* SACK Block */
++#define TCPOPT_TIMESTAMP	8	/* Better RTT estimations/PAWS */
++#define TCPOPT_MD5SIG		19	/* MD5 Signature (RFC2385) */
++#define TCPOPT_EXP		254	/* Experimental */
++/* Magic number to be after the option value for sharing TCP
++ * experimental options. See draft-ietf-tcpm-experimental-options-00.txt
++ */
++#define TCPOPT_FASTOPEN_MAGIC	0xF989
++
++/*
++ *     TCP option lengths
++ */
++
++#define TCPOLEN_MSS            4
++#define TCPOLEN_WINDOW         3
++#define TCPOLEN_SACK_PERM      2
++#define TCPOLEN_TIMESTAMP      10
++#define TCPOLEN_MD5SIG         18
++#define TCPOLEN_EXP_FASTOPEN_BASE  4
++
++/* But this is what stacks really send out. */
++#define TCPOLEN_TSTAMP_ALIGNED		12
++#define TCPOLEN_WSCALE_ALIGNED		4
++#define TCPOLEN_SACKPERM_ALIGNED	4
++#define TCPOLEN_SACK_BASE		2
++#define TCPOLEN_SACK_BASE_ALIGNED	4
++#define TCPOLEN_SACK_PERBLOCK		8
++#define TCPOLEN_MD5SIG_ALIGNED		20
++#define TCPOLEN_MSS_ALIGNED		4
++
++/* Flags in tp->nonagle */
++#define TCP_NAGLE_OFF		1	/* Nagle's algo is disabled */
++#define TCP_NAGLE_CORK		2	/* Socket is corked	    */
++#define TCP_NAGLE_PUSH		4	/* Cork is overridden for already queued data */
++
++/* TCP thin-stream limits */
++#define TCP_THIN_LINEAR_RETRIES 6       /* After 6 linear retries, do exp. backoff */
++
++/* TCP initial congestion window as per draft-hkchu-tcpm-initcwnd-01 */
++#define TCP_INIT_CWND		10
++
++/* Bit Flags for sysctl_tcp_fastopen */
++#define	TFO_CLIENT_ENABLE	1
++#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
++
++/* Force enable TFO on all listeners, i.e., not requiring the
++ * TCP_FASTOPEN socket option. SOCKOPT1/2 determine how to set max_qlen.
++ */
++#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;
++
++/* sysctl variables for tcp */
++extern int sysctl_tcp_timestamps;
++extern int sysctl_tcp_window_scaling;
++extern int sysctl_tcp_sack;
++extern int sysctl_tcp_fin_timeout;
++extern int sysctl_tcp_keepalive_time;
++extern int sysctl_tcp_keepalive_probes;
++extern int sysctl_tcp_keepalive_intvl;
++extern int sysctl_tcp_syn_retries;
++extern int sysctl_tcp_synack_retries;
++extern int sysctl_tcp_retries1;
++extern int sysctl_tcp_retries2;
++extern int sysctl_tcp_orphan_retries;
++extern int sysctl_tcp_syncookies;
++extern int sysctl_tcp_fastopen;
++extern int sysctl_tcp_retrans_collapse;
++extern int sysctl_tcp_stdurg;
++extern int sysctl_tcp_rfc1337;
++extern int sysctl_tcp_abort_on_overflow;
++extern int sysctl_tcp_max_orphans;
++extern int sysctl_tcp_fack;
++extern int sysctl_tcp_reordering;
++extern int sysctl_tcp_dsack;
++extern long sysctl_tcp_mem[3];
++extern int sysctl_tcp_wmem[3];
++extern int sysctl_tcp_rmem[3];
++extern int sysctl_tcp_app_win;
++extern int sysctl_tcp_adv_win_scale;
++extern int sysctl_tcp_tw_reuse;
++extern int sysctl_tcp_frto;
++extern int sysctl_tcp_low_latency;
++extern int sysctl_tcp_dma_copybreak;
++extern int sysctl_tcp_nometrics_save;
++extern int sysctl_tcp_moderate_rcvbuf;
++extern int sysctl_tcp_tso_win_divisor;
++extern int sysctl_tcp_mtu_probing;
++extern int sysctl_tcp_base_mss;
++extern int sysctl_tcp_workaround_signed_windows;
++extern int sysctl_tcp_slow_start_after_idle;
++extern int sysctl_tcp_thin_linear_timeouts;
++extern int sysctl_tcp_thin_dupack;
++extern int sysctl_tcp_early_retrans;
++extern int sysctl_tcp_limit_output_bytes;
++extern int sysctl_tcp_challenge_ack_limit;
++extern unsigned int sysctl_tcp_notsent_lowat;
++extern int sysctl_tcp_min_tso_segs;
++extern int sysctl_tcp_autocorking;
++
++extern atomic_long_t tcp_memory_allocated;
++extern struct percpu_counter tcp_sockets_allocated;
++extern int tcp_memory_pressure;
++
++/*
++ * The next routines deal with comparing 32 bit unsigned ints
++ * and worry about wraparound (automatic with unsigned arithmetic).
++ */
++
++static inline bool before(__u32 seq1, __u32 seq2)
++{
++        return (__s32)(seq1-seq2) < 0;
++}
++#define after(seq2, seq1) 	before(seq1, seq2)
++
++/* is s2<=s1<=s3 ? */
++static inline bool between(__u32 seq1, __u32 seq2, __u32 seq3)
++{
++	return seq3 - seq2 >= seq1 - seq2;
++}
++
++static inline bool tcp_out_of_memory(struct sock *sk)
++{
++	if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
++	    sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
++		return true;
++	return false;
++}
++
++static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
++{
++	struct percpu_counter *ocp = sk->sk_prot->orphan_count;
++	int orphans = percpu_counter_read_positive(ocp);
++
++	if (orphans << shift > sysctl_tcp_max_orphans) {
++		orphans = percpu_counter_sum_positive(ocp);
++		if (orphans << shift > sysctl_tcp_max_orphans)
++			return true;
++	}
++	return false;
++}
++
++bool tcp_check_oom(struct sock *sk, int shift);
++
++/* syncookies: remember time of last synqueue overflow */
++static inline void tcp_synq_overflow(struct sock *sk)
++{
++	tcp_sk(sk)->rx_opt.ts_recent_stamp = jiffies;
++}
++
++/* syncookies: no recent synqueue overflow on this listening socket? */
++static inline bool tcp_synq_no_recent_overflow(const struct sock *sk)
++{
++	unsigned long last_overflow = tcp_sk(sk)->rx_opt.ts_recent_stamp;
++	return time_after(jiffies, last_overflow + TCP_TIMEOUT_FALLBACK);
++}
++
++extern struct proto tcp_prot;
++
++#define TCP_INC_STATS(net, field)	SNMP_INC_STATS((net)->mib.tcp_statistics, field)
++#define TCP_INC_STATS_BH(net, field)	SNMP_INC_STATS_BH((net)->mib.tcp_statistics, field)
++#define TCP_DEC_STATS(net, field)	SNMP_DEC_STATS((net)->mib.tcp_statistics, field)
++#define TCP_ADD_STATS_USER(net, field, val) SNMP_ADD_STATS_USER((net)->mib.tcp_statistics, field, val)
++#define TCP_ADD_STATS(net, field, val)	SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val)
++
++void tcp_tasklet_init(void);
++
++void tcp_v4_err(struct sk_buff *skb, u32);
++
++void tcp_shutdown(struct sock *sk, int how);
++
++void tcp_v4_early_demux(struct sk_buff *skb);
++int tcp_v4_rcv(struct sk_buff *skb);
++
++int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
++int tcp_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
++		size_t size);
++int tcp_sendpage(struct sock *sk, struct page *page, int offset, size_t size,
++		 int flags);
++void tcp_release_cb(struct sock *sk);
++void tcp_wfree(struct sk_buff *skb);
++void tcp_write_timer_handler(struct sock *sk);
++void tcp_delack_timer_handler(struct sock *sk);
++int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
++int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
++			  const struct tcphdr *th, unsigned int len);
++void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
++			 const struct tcphdr *th, unsigned int len);
++void tcp_rcv_space_adjust(struct sock *sk);
++void tcp_cleanup_rbuf(struct sock *sk, int copied);
++int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp);
++void tcp_twsk_destructor(struct sock *sk);
++ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos,
++			struct pipe_inode_info *pipe, size_t len,
++			unsigned int flags);
++
++static inline void tcp_dec_quickack_mode(struct sock *sk,
++					 const unsigned int pkts)
++{
++	struct inet_connection_sock *icsk = inet_csk(sk);
++
++	if (icsk->icsk_ack.quick) {
++		if (pkts >= icsk->icsk_ack.quick) {
++			icsk->icsk_ack.quick = 0;
++			/* Leaving quickack mode we deflate ATO. */
++			icsk->icsk_ack.ato   = TCP_ATO_MIN;
++		} else
++			icsk->icsk_ack.quick -= pkts;
++	}
++}
++
++#define	TCP_ECN_OK		1
++#define	TCP_ECN_QUEUE_CWR	2
++#define	TCP_ECN_DEMAND_CWR	4
++#define	TCP_ECN_SEEN		8
++
++enum tcp_tw_status {
++	TCP_TW_SUCCESS = 0,
++	TCP_TW_RST = 1,
++	TCP_TW_ACK = 2,
++	TCP_TW_SYN = 3
++};
++
++
++enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw,
++					      struct sk_buff *skb,
++					      const struct tcphdr *th);
++struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
++			   struct request_sock *req, struct request_sock **prev,
++			   bool fastopen);
++int tcp_child_process(struct sock *parent, struct sock *child,
++		      struct sk_buff *skb);
++void tcp_enter_loss(struct sock *sk, int how);
++void tcp_clear_retrans(struct tcp_sock *tp);
++void tcp_update_metrics(struct sock *sk);
++void tcp_init_metrics(struct sock *sk);
++void tcp_metrics_init(void);
++bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst,
++			bool paws_check);
++bool tcp_remember_stamp(struct sock *sk);
++bool tcp_tw_remember_stamp(struct inet_timewait_sock *tw);
++void tcp_fetch_timewait_stamp(struct sock *sk, struct dst_entry *dst);
++void tcp_disable_fack(struct tcp_sock *tp);
++void tcp_close(struct sock *sk, long timeout);
++void tcp_init_sock(struct sock *sk);
++unsigned int tcp_poll(struct file *file, struct socket *sock,
++		      struct poll_table_struct *wait);
++int tcp_getsockopt(struct sock *sk, int level, int optname,
++		   char __user *optval, int __user *optlen);
++int tcp_setsockopt(struct sock *sk, int level, int optname,
++		   char __user *optval, unsigned int optlen);
++int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
++			  char __user *optval, int __user *optlen);
++int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
++			  char __user *optval, unsigned int optlen);
++void tcp_set_keepalive(struct sock *sk, int val);
++void tcp_syn_ack_timeout(struct sock *sk, struct request_sock *req);
++int tcp_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg,
++		size_t len, int nonblock, int flags, int *addr_len);
++void tcp_parse_options(const struct sk_buff *skb,
++		       struct tcp_options_received *opt_rx,
++		       int estab, struct tcp_fastopen_cookie *foc);
++const u8 *tcp_parse_md5sig_option(const struct tcphdr *th);
++
++/*
++ *	TCP v4 functions exported for the inet6 API
++ */
++
++void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb);
++int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb);
++struct sock *tcp_create_openreq_child(struct sock *sk,
++				      struct request_sock *req,
++				      struct sk_buff *skb);
++struct sock *tcp_v4_syn_recv_sock(struct sock *sk, struct sk_buff *skb,
++				  struct request_sock *req,
++				  struct dst_entry *dst);
++int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);
++int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
++int tcp_connect(struct sock *sk);
++struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst,
++				struct request_sock *req,
++				struct tcp_fastopen_cookie *foc);
++int tcp_disconnect(struct sock *sk, int flags);
++
++void tcp_finish_connect(struct sock *sk, struct sk_buff *skb);
++int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size);
++void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb);
++
++/* From syncookies.c */
++int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th,
++		      u32 cookie);
++struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb,
++			     struct ip_options *opt);
++#ifdef CONFIG_SYN_COOKIES
++
++/* Syncookies use a monotonic timer which increments every 60 seconds.
++ * This counter is used both as a hash input and partially encoded into
++ * the cookie value.  A cookie is only validated further if the delta
++ * between the current counter value and the encoded one is less than this,
++ * i.e. a sent cookie is valid only at most for 2*60 seconds (or less if
++ * the counter advances immediately after a cookie is generated).
++ */
++#define MAX_SYNCOOKIE_AGE 2
++
++static inline u32 tcp_cookie_time(void)
++{
++	u64 val = get_jiffies_64();
++
++	do_div(val, 60 * HZ);
++	return val;
++}
++
++u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr *th,
++			      u16 *mssp);
++__u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, __u16 *mss);
++#else
++static inline __u32 cookie_v4_init_sequence(struct sock *sk,
++					    struct sk_buff *skb,
++					    __u16 *mss)
++{
++	return 0;
++}
++#endif
++
++__u32 cookie_init_timestamp(struct request_sock *req);
++bool cookie_check_timestamp(struct tcp_options_received *opt, struct net *net,
++			    bool *ecn_ok);
++
++/* From net/ipv6/syncookies.c */
++int __cookie_v6_check(const struct ipv6hdr *iph, const struct tcphdr *th,
++		      u32 cookie);
++struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb);
++#ifdef CONFIG_SYN_COOKIES
++u32 __cookie_v6_init_sequence(const struct ipv6hdr *iph,
++			      const struct tcphdr *th, u16 *mssp);
++__u32 cookie_v6_init_sequence(struct sock *sk, const struct sk_buff *skb,
++			      __u16 *mss);
++#else
++static inline __u32 cookie_v6_init_sequence(struct sock *sk,
++					    struct sk_buff *skb,
++					    __u16 *mss)
++{
++	return 0;
++}
++#endif
++/* tcp_output.c */
++
++void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
++			       int nonagle);
++bool tcp_may_send_now(struct sock *sk);
++int __tcp_retransmit_skb(struct sock *, struct sk_buff *);
++int tcp_retransmit_skb(struct sock *, struct sk_buff *);
++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);
++
++void tcp_send_probe0(struct sock *);
++void tcp_send_partial(struct sock *);
++int tcp_write_wakeup(struct sock *);
++void tcp_send_fin(struct sock *sk);
++void tcp_send_active_reset(struct sock *sk, gfp_t priority);
++int tcp_send_synack(struct sock *);
++bool tcp_syn_flood_action(struct sock *sk, const struct sk_buff *skb,
++			  const char *proto);
++void tcp_push_one(struct sock *, unsigned int mss_now);
++void tcp_send_ack(struct sock *sk);
++void tcp_send_delayed_ack(struct sock *sk);
++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);
++
++/* tcp_timer.c */
++void tcp_init_xmit_timers(struct sock *);
++static inline void tcp_clear_xmit_timers(struct sock *sk)
++{
++	inet_csk_clear_xmit_timers(sk);
++}
++
++unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
++unsigned int tcp_current_mss(struct sock *sk);
++
++/* Bound MSS / TSO packet size with the half of the window */
++static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)
++{
++	int cutoff;
++
++	/* When peer uses tiny windows, there is no use in packetizing
++	 * to sub-MSS pieces for the sake of SWS or making sure there
++	 * are enough packets in the pipe for fast recovery.
++	 *
++	 * On the other hand, for extremely large MSS devices, handling
++	 * smaller than MSS windows in this way does make sense.
++	 */
++	if (tp->max_window >= 512)
++		cutoff = (tp->max_window >> 1);
++	else
++		cutoff = tp->max_window;
++
++	if (cutoff && pktsize > cutoff)
++		return max_t(int, cutoff, 68U - tp->tcp_header_len);
++	else
++		return pktsize;
++}
++
++/* tcp.c */
++void tcp_get_info(const struct sock *, struct tcp_info *);
++
++/* Read 'sendfile()'-style from a TCP socket */
++typedef int (*sk_read_actor_t)(read_descriptor_t *, struct sk_buff *,
++				unsigned int, size_t);
++int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
++		  sk_read_actor_t recv_actor);
++
++void tcp_initialize_rcv_mss(struct sock *sk);
++
++int tcp_mtu_to_mss(struct sock *sk, int pmtu);
++int tcp_mss_to_mtu(struct sock *sk, int mss);
++void tcp_mtup_init(struct sock *sk);
++void tcp_init_buffer_space(struct sock *sk);
++
++static inline void tcp_bound_rto(const struct sock *sk)
++{
++	if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
++		inet_csk(sk)->icsk_rto = TCP_RTO_MAX;
++}
++
++static inline u32 __tcp_set_rto(const struct tcp_sock *tp)
++{
++	return usecs_to_jiffies((tp->srtt_us >> 3) + tp->rttvar_us);
++}
++
++static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
++{
++	tp->pred_flags = htonl((tp->tcp_header_len << 26) |
++			       ntohl(TCP_FLAG_ACK) |
++			       snd_wnd);
++}
++
++static inline void tcp_fast_path_on(struct tcp_sock *tp)
++{
++	__tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
++}
++
++static inline void tcp_fast_path_check(struct sock *sk)
++{
++	struct tcp_sock *tp = tcp_sk(sk);
++
++	if (skb_queue_empty(&tp->out_of_order_queue) &&
++	    tp->rcv_wnd &&
++	    atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
++	    !tp->urg_data)
++		tcp_fast_path_on(tp);
++}
++
++/* Compute the actual rto_min value */
++static inline u32 tcp_rto_min(struct sock *sk)
++{
++	const struct dst_entry *dst = __sk_dst_get(sk);
++	u32 rto_min = TCP_RTO_MIN;
++
++	if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
++		rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);
++	return rto_min;
++}
++
++static inline u32 tcp_rto_min_us(struct sock *sk)
++{
++	return jiffies_to_usecs(tcp_rto_min(sk));
++}
++
++/* Compute the actual receive window we are currently advertising.
++ * Rcv_nxt can be after the window if our peer push more data
++ * than the offered window.
++ */
++static inline u32 tcp_receive_window(const struct tcp_sock *tp)
++{
++	s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
++
++	if (win < 0)
++		win = 0;
++	return (u32) win;
++}
++
++/* Choose a new window, without checks for shrinking, and without
++ * scaling applied to the result.  The caller does these things
++ * if necessary.  This is a "raw" window selection.
++ */
++u32 __tcp_select_window(struct sock *sk);
++
++void tcp_send_window_probe(struct sock *sk);
++
++/* TCP timestamps are only 32-bits, this causes a slight
++ * complication on 64-bit systems since we store a snapshot
++ * of jiffies in the buffer control blocks below.  We decided
++ * to use only the low 32-bits of jiffies and hide the ugly
++ * casts with the following macro.
++ */
++#define tcp_time_stamp		((__u32)(jiffies))
++
++#define tcp_flag_byte(th) (((u_int8_t *)th)[13])
++
++#define TCPHDR_FIN 0x01
++#define TCPHDR_SYN 0x02
++#define TCPHDR_RST 0x04
++#define TCPHDR_PSH 0x08
++#define TCPHDR_ACK 0x10
++#define TCPHDR_URG 0x20
++#define TCPHDR_ECE 0x40
++#define TCPHDR_CWR 0x80
++
++/* This is what the send packet queuing engine uses to pass
++ * TCP per-packet control information to the transmission code.
++ * We also store the host-order sequence numbers in here too.
++ * This is 44 bytes if IPV6 is enabled.
++ * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately.
++ */
++struct tcp_skb_cb {
++	union {
++		struct inet_skb_parm	h4;
++#if IS_ENABLED(CONFIG_IPV6)
++		struct inet6_skb_parm	h6;
++#endif
++	} header;	/* For incoming frames		*/
++	__u32		seq;		/* Starting sequence number	*/
++	__u32		end_seq;	/* SEQ + FIN + SYN + datalen	*/
++	__u32		when;		/* used to compute rtt's	*/
++	__u8		tcp_flags;	/* TCP header flags. (tcp[13])	*/
++
++	__u8		sacked;		/* State flags for SACK/FACK.	*/
++#define TCPCB_SACKED_ACKED	0x01	/* SKB ACK'd by a SACK block	*/
++#define TCPCB_SACKED_RETRANS	0x02	/* SKB retransmitted		*/
++#define TCPCB_LOST		0x04	/* SKB is lost			*/
++#define TCPCB_TAGBITS		0x07	/* All tag bits			*/
++#define TCPCB_EVER_RETRANS	0x80	/* Ever retransmitted frame	*/
++#define TCPCB_RETRANS		(TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS)
++
++	__u8		ip_dsfield;	/* IPv4 tos or IPv6 dsfield	*/
++	/* 1 byte hole */
++	__u32		ack_seq;	/* Sequence number ACK'd	*/
++};
++
++#defin