lael-labs/linux

include/linux/bitmap.h+4−0

  *  bitmap_find_next_zero_area_off(buf, len, pos, n, mask)  as above
  *  bitmap_shift_right(dst, src, n, nbits)      *dst = *src >> n
  *  bitmap_shift_left(dst, src, n, nbits)       *dst = *src << n
+ *  bitmap_cut(dst, src, first, n, nbits)       Cut n bits from first, copy rest
  *  bitmap_replace(dst, old, new, mask, nbits)  *dst = (*old & ~(*mask)) | (*new & *mask)
  *  bitmap_remap(dst, src, old, new, nbits)     *dst = map(old, new)(src)
  *  bitmap_bitremap(oldbit, old, new, nbits)    newbit = map(old, new)(oldbit)
 				unsigned int shift, unsigned int nbits);
 extern void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
 				unsigned int shift, unsigned int nbits);
+extern void bitmap_cut(unsigned long *dst, const unsigned long *src,
+		       unsigned int first, unsigned int cut,
+		       unsigned int nbits);
 extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
 			const unsigned long *bitmap2, unsigned int nbits);
 extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,

include/linux/bpf-cgroup.h+3−1

 void cgroup_bpf_offline(struct cgroup *cgrp);
 int __cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog,
+			struct bpf_prog *replace_prog,
 			enum bpf_attach_type type, u32 flags);
 int __cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,
 			enum bpf_attach_type type);
 /* Wrapper for __cgroup_bpf_*() protected by cgroup_mutex */
 int cgroup_bpf_attach(struct cgroup *cgrp, struct bpf_prog *prog,
-		      enum bpf_attach_type type, u32 flags);
+		      struct bpf_prog *replace_prog, enum bpf_attach_type type,
+		      u32 flags);
 int cgroup_bpf_detach(struct cgroup *cgrp, struct bpf_prog *prog,
 		      enum bpf_attach_type type, u32 flags);
 int cgroup_bpf_query(struct cgroup *cgrp, const union bpf_attr *attr,

include/linux/bpf.h+206−8

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	#include <linux/u64_stats_sync.h>	17	#include <linux/u64_stats_sync.h>
18	#include <linux/refcount.h>	18	#include <linux/refcount.h>
19	#include <linux/mutex.h>	19	#include <linux/mutex.h>
		20	#include <linux/module.h>
20		21
21	struct bpf_verifier_env;	22	struct bpf_verifier_env;
22	struct bpf_verifier_log;	23	struct bpf_verifier_log;
@@ -43,6 +44,15 @@ struct bpf_map_ops { · 20 unmodified lines
43	int (map_get_next_key)(struct bpf_map map, void key, void next_key);	44	int (map_get_next_key)(struct bpf_map map, void key, void next_key);
44	void (map_release_uref)(struct bpf_map map);	45	void (map_release_uref)(struct bpf_map map);
45	void (map_lookup_elem_sys_only)(struct bpf_map map, void key);	46	void (map_lookup_elem_sys_only)(struct bpf_map map, void key);
		47	int (map_lookup_batch)(struct bpf_map map, const union bpf_attr *attr,
		48	union bpf_attr __user *uattr);
		49	int (map_lookup_and_delete_batch)(struct bpf_map map,
		50	const union bpf_attr *attr,
		51	union bpf_attr __user *uattr);
		52	int (map_update_batch)(struct bpf_map map, const union bpf_attr *attr,
		53	union bpf_attr __user *uattr);
		54	int (map_delete_batch)(struct bpf_map map, const union bpf_attr *attr,
		55	union bpf_attr __user *uattr);
46		56
47	/* funcs callable from userspace and from eBPF programs */	57	/* funcs callable from userspace and from eBPF programs */
48	void (map_lookup_elem)(struct bpf_map map, void key);	58	void (map_lookup_elem)(struct bpf_map map, void key);
@@ -106,6 +116,7 @@ struct bpf_map { · 57 unmodified lines
106	struct btf *btf;	116	struct btf *btf;
107	struct bpf_map_memory memory;	117	struct bpf_map_memory memory;
108	char name[BPF_OBJ_NAME_LEN];	118	char name[BPF_OBJ_NAME_LEN];
		119	u32 btf_vmlinux_value_type_id;
109	bool unpriv_array;	120	bool unpriv_array;
110	bool frozen; /* write-once; write-protected by freeze_mutex */	121	bool frozen; /* write-once; write-protected by freeze_mutex */
111	/* 22 bytes hole */	122	/* 22 bytes hole */
@@ -183,7 +194,8 @@ static inline bool bpf_map_offload_neutral(const struct bpf_map *map) · 71 unmodified lines
183		194
184	static inline bool bpf_map_support_seq_show(const struct bpf_map *map)	195	static inline bool bpf_map_support_seq_show(const struct bpf_map *map)
185	{	196	{
186	return map->btf && map->ops->map_seq_show_elem;	197	return (map->btf_value_type_id \|\| map->btf_vmlinux_value_type_id) &&
		198	map->ops->map_seq_show_elem;
187	}	199	}
188		200
189	int map_check_no_btf(const struct bpf_map *map,	201	int map_check_no_btf(const struct bpf_map *map,
@@ -349,6 +361,10 @@ struct bpf_verifier_ops { · 159 unmodified lines
349	const struct bpf_insn *src,	361	const struct bpf_insn *src,
350	struct bpf_insn *dst,	362	struct bpf_insn *dst,
351	struct bpf_prog prog, u32 target_size);	363	struct bpf_prog prog, u32 target_size);
		364	int (btf_struct_access)(struct bpf_verifier_log log,
		365	const struct btf_type *t, int off, int size,
		366	enum bpf_access_type atype,
		367	u32 *next_btf_id);
352	};	368	};
353		369
354	struct bpf_prog_offload_ops {	370	struct bpf_prog_offload_ops {
@@ -437,7 +453,8 @@ struct btf_func_model { · 82 unmodified lines
437	* fentry = a set of program to run before calling original function	453	* fentry = a set of program to run before calling original function
438	* fexit = a set of program to run after original function	454	* fexit = a set of program to run after original function
439	*/	455	*/
440	int arch_prepare_bpf_trampoline(void image, struct btf_func_model m, u32 flags,	456	int arch_prepare_bpf_trampoline(void image, void image_end,
		457	const struct btf_func_model *m, u32 flags,
441	struct bpf_prog **fentry_progs, int fentry_cnt,	458	struct bpf_prog **fentry_progs, int fentry_cnt,
442	struct bpf_prog **fexit_progs, int fexit_cnt,	459	struct bpf_prog **fexit_progs, int fexit_cnt,
443	void *orig_call);	460	void *orig_call);
@@ -448,7 +465,8 @@ void notrace __bpf_prog_exit(struct bpf_prog *prog, u64 start); · 4 unmodified lines
448	enum bpf_tramp_prog_type {	465	enum bpf_tramp_prog_type {
449	BPF_TRAMP_FENTRY,	466	BPF_TRAMP_FENTRY,
450	BPF_TRAMP_FEXIT,	467	BPF_TRAMP_FEXIT,
451	BPF_TRAMP_MAX	468	BPF_TRAMP_MAX,
		469	BPF_TRAMP_REPLACE, /* more than MAX */
452	};	470	};
453		471
454	struct bpf_trampoline {	472	struct bpf_trampoline {
@@ -463,6 +481,11 @@ struct bpf_trampoline { · 8 unmodified lines
463	void *addr;	481	void *addr;
464	bool ftrace_managed;	482	bool ftrace_managed;
465	} func;	483	} func;
		484	/* if !NULL this is BPF_PROG_TYPE_EXT program that extends another BPF
		485	* program by replacing one of its functions. func.addr is the address
		486	* of the function it replaced.
		487	*/
		488	struct bpf_prog *extension_prog;
466	/* list of BPF programs using this trampoline */	489	/* list of BPF programs using this trampoline */
467	struct hlist_head progs_hlist[BPF_TRAMP_MAX];	490	struct hlist_head progs_hlist[BPF_TRAMP_MAX];
468	/* Number of attached programs. A counter per kind. */	491	/* Number of attached programs. A counter per kind. */
@@ -471,11 +494,75 @@ struct bpf_trampoline { · 2 unmodified lines
471	void *image;	494	void *image;
472	u64 selector;	495	u64 selector;
473	};	496	};
		497
		498	#define BPF_DISPATCHER_MAX 48 /* Fits in 2048B */
		499
		500	struct bpf_dispatcher_prog {
		501	struct bpf_prog *prog;
		502	refcount_t users;
		503	};
		504
		505	struct bpf_dispatcher {
		506	/* dispatcher mutex */
		507	struct mutex mutex;
		508	void *func;
		509	struct bpf_dispatcher_prog progs[BPF_DISPATCHER_MAX];
		510	int num_progs;
		511	void *image;
		512	u32 image_off;
		513	};
		514
		515	static __always_inline unsigned int bpf_dispatcher_nopfunc(
		516	const void *ctx,
		517	const struct bpf_insn *insnsi,
		518	unsigned int (bpf_func)(const void ,
		519	const struct bpf_insn *))
		520	{
		521	return bpf_func(ctx, insnsi);
		522	}
474	#ifdef CONFIG_BPF_JIT	523	#ifdef CONFIG_BPF_JIT
475	struct bpf_trampoline *bpf_trampoline_lookup(u64 key);	524	struct bpf_trampoline *bpf_trampoline_lookup(u64 key);
476	int bpf_trampoline_link_prog(struct bpf_prog *prog);	525	int bpf_trampoline_link_prog(struct bpf_prog *prog);
477	int bpf_trampoline_unlink_prog(struct bpf_prog *prog);	526	int bpf_trampoline_unlink_prog(struct bpf_prog *prog);
478	void bpf_trampoline_put(struct bpf_trampoline *tr);	527	void bpf_trampoline_put(struct bpf_trampoline *tr);
		528	#define BPF_DISPATCHER_INIT(name) { \
		529	.mutex = __MUTEX_INITIALIZER(name.mutex), \
		530	.func = &name##func, \
		531	.progs = {}, \
		532	.num_progs = 0, \
		533	.image = NULL, \
		534	.image_off = 0 \
		535	}
		536
		537	#define DEFINE_BPF_DISPATCHER(name) \
		538	noinline unsigned int name##func( \
		539	const void *ctx, \
		540	const struct bpf_insn *insnsi, \
		541	unsigned int (bpf_func)(const void , \
		542	const struct bpf_insn *)) \
		543	{ \
		544	return bpf_func(ctx, insnsi); \
		545	} \
		546	EXPORT_SYMBOL(name##func); \
		547	struct bpf_dispatcher name = BPF_DISPATCHER_INIT(name);
		548	#define DECLARE_BPF_DISPATCHER(name) \
		549	unsigned int name##func( \
		550	const void *ctx, \
		551	const struct bpf_insn *insnsi, \
		552	unsigned int (bpf_func)(const void , \
		553	const struct bpf_insn *)); \
		554	extern struct bpf_dispatcher name;
		555	#define BPF_DISPATCHER_FUNC(name) name##func
		556	#define BPF_DISPATCHER_PTR(name) (&name)
		557	void bpf_dispatcher_change_prog(struct bpf_dispatcher d, struct bpf_prog from,
		558	struct bpf_prog *to);
		559	struct bpf_image {
		560	struct latch_tree_node tnode;
		561	unsigned char data[];
		562	};
		563	#define BPF_IMAGE_SIZE (PAGE_SIZE - sizeof(struct bpf_image))
		564	bool is_bpf_image_address(unsigned long address);
		565	void *bpf_image_alloc(void);
479	#else	566	#else
480	static inline struct bpf_trampoline *bpf_trampoline_lookup(u64 key)	567	static inline struct bpf_trampoline *bpf_trampoline_lookup(u64 key)
481	{	568	{
@@ -490,9 +577,21 @@ static inline int bpf_trampoline_unlink_prog(struct bpf_prog *prog) · 8 unmodified lines
490	return -ENOTSUPP;	577	return -ENOTSUPP;
491	}	578	}
492	static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}	579	static inline void bpf_trampoline_put(struct bpf_trampoline *tr) {}
		580	#define DEFINE_BPF_DISPATCHER(name)
		581	#define DECLARE_BPF_DISPATCHER(name)
		582	#define BPF_DISPATCHER_FUNC(name) bpf_dispatcher_nopfunc
		583	#define BPF_DISPATCHER_PTR(name) NULL
		584	static inline void bpf_dispatcher_change_prog(struct bpf_dispatcher *d,
		585	struct bpf_prog *from,
		586	struct bpf_prog *to) {}
		587	static inline bool is_bpf_image_address(unsigned long address)
		588	{
		589	return false;
		590	}
493	#endif	591	#endif
494		592
495	struct bpf_func_info_aux {	593	struct bpf_func_info_aux {
		594	u16 linkage;
496	bool unreliable;	595	bool unreliable;
497	};	596	};
498		597
@@ -603,6 +702,73 @@ struct bpf_array_aux { · 104 unmodified lines
603	struct work_struct work;	702	struct work_struct work;
604	};	703	};
605		704
		705	struct bpf_struct_ops_value;
		706	struct btf_type;
		707	struct btf_member;
		708
		709	#define BPF_STRUCT_OPS_MAX_NR_MEMBERS 64
		710	struct bpf_struct_ops {
		711	const struct bpf_verifier_ops *verifier_ops;
		712	int (init)(struct btf btf);
		713	int (check_member)(const struct btf_type t,
		714	const struct btf_member *member);
		715	int (init_member)(const struct btf_type t,
		716	const struct btf_member *member,
		717	void kdata, const void udata);
		718	int (reg)(void kdata);
		719	void (unreg)(void kdata);
		720	const struct btf_type *type;
		721	const struct btf_type *value_type;
		722	const char *name;
		723	struct btf_func_model func_models[BPF_STRUCT_OPS_MAX_NR_MEMBERS];
		724	u32 type_id;
		725	u32 value_id;
		726	};
		727
		728	#if defined(CONFIG_BPF_JIT) && defined(CONFIG_BPF_SYSCALL)
		729	#define BPF_MODULE_OWNER ((void *)((0xeB9FUL << 2) + POISON_POINTER_DELTA))
		730	const struct bpf_struct_ops *bpf_struct_ops_find(u32 type_id);
		731	void bpf_struct_ops_init(struct btf *btf);
		732	bool bpf_struct_ops_get(const void *kdata);
		733	void bpf_struct_ops_put(const void *kdata);
		734	int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map map, void key,
		735	void *value);
		736	static inline bool bpf_try_module_get(const void data, struct module owner)
		737	{
		738	if (owner == BPF_MODULE_OWNER)
		739	return bpf_struct_ops_get(data);
		740	else
		741	return try_module_get(owner);
		742	}
		743	static inline void bpf_module_put(const void data, struct module owner)
		744	{
		745	if (owner == BPF_MODULE_OWNER)
		746	bpf_struct_ops_put(data);
		747	else
		748	module_put(owner);
		749	}
		750	#else
		751	static inline const struct bpf_struct_ops *bpf_struct_ops_find(u32 type_id)
		752	{
		753	return NULL;
		754	}
		755	static inline void bpf_struct_ops_init(struct btf *btf) { }
		756	static inline bool bpf_try_module_get(const void data, struct module owner)
		757	{
		758	return try_module_get(owner);
		759	}
		760	static inline void bpf_module_put(const void data, struct module owner)
		761	{
		762	module_put(owner);
		763	}
		764	static inline int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map *map,
		765	void *key,
		766	void *value)
		767	{
		768	return -EINVAL;
		769	}
		770	#endif
		771
606	struct bpf_array {	772	struct bpf_array {
607	struct bpf_map map;	773	struct bpf_map map;
608	u32 elem_size;	774	u32 elem_size;
@@ -841,6 +1007,15 @@ void *bpf_map_area_alloc(u64 size, int numa_node); · 232 unmodified lines
841	void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);	1007	void *bpf_map_area_mmapable_alloc(u64 size, int numa_node);
842	void bpf_map_area_free(void *base);	1008	void bpf_map_area_free(void *base);
843	void bpf_map_init_from_attr(struct bpf_map map, union bpf_attr attr);	1009	void bpf_map_init_from_attr(struct bpf_map map, union bpf_attr attr);
		1010	int generic_map_lookup_batch(struct bpf_map *map,
		1011	const union bpf_attr *attr,
		1012	union bpf_attr __user *uattr);
		1013	int generic_map_update_batch(struct bpf_map *map,
		1014	const union bpf_attr *attr,
		1015	union bpf_attr __user *uattr);
		1016	int generic_map_delete_batch(struct bpf_map *map,
		1017	const union bpf_attr *attr,
		1018	union bpf_attr __user *uattr);
844		1019
845	extern int sysctl_unprivileged_bpf_disabled;	1020	extern int sysctl_unprivileged_bpf_disabled;
846		1021
@@ -897,14 +1072,16 @@ struct sk_buff; · 50 unmodified lines
897		1072
898	struct bpf_dtab_netdev __dev_map_lookup_elem(struct bpf_map map, u32 key);	1073	struct bpf_dtab_netdev __dev_map_lookup_elem(struct bpf_map map, u32 key);
899	struct bpf_dtab_netdev __dev_map_hash_lookup_elem(struct bpf_map map, u32 key);	1074	struct bpf_dtab_netdev __dev_map_hash_lookup_elem(struct bpf_map map, u32 key);
900	void __dev_map_flush(struct bpf_map *map);	1075	void __dev_flush(void);
		1076	int dev_xdp_enqueue(struct net_device dev, struct xdp_buff xdp,
		1077	struct net_device *dev_rx);
901	int dev_map_enqueue(struct bpf_dtab_netdev dst, struct xdp_buff xdp,	1078	int dev_map_enqueue(struct bpf_dtab_netdev dst, struct xdp_buff xdp,
902	struct net_device *dev_rx);	1079	struct net_device *dev_rx);
903	int dev_map_generic_redirect(struct bpf_dtab_netdev dst, struct sk_buff skb,	1080	int dev_map_generic_redirect(struct bpf_dtab_netdev dst, struct sk_buff skb,
904	struct bpf_prog *xdp_prog);	1081	struct bpf_prog *xdp_prog);
905		1082
906	struct bpf_cpu_map_entry __cpu_map_lookup_elem(struct bpf_map map, u32 key);	1083	struct bpf_cpu_map_entry __cpu_map_lookup_elem(struct bpf_map map, u32 key);
907	void __cpu_map_flush(struct bpf_map *map);	1084	void __cpu_map_flush(void);
908	int cpu_map_enqueue(struct bpf_cpu_map_entry rcpu, struct xdp_buff xdp,	1085	int cpu_map_enqueue(struct bpf_cpu_map_entry rcpu, struct xdp_buff xdp,
909	struct net_device *dev_rx);	1086	struct net_device *dev_rx);
910		1087
@@ -941,7 +1118,15 @@ int btf_distill_func_proto(struct bpf_verifier_log *log, · 30 unmodified lines
941	const char *func_name,	1118	const char *func_name,
942	struct btf_func_model *m);	1119	struct btf_func_model *m);
943		1120
944	int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog);	1121	struct bpf_reg_state;
		1122	int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog,
		1123	struct bpf_reg_state *regs);
		1124	int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog,
		1125	struct bpf_reg_state *reg);
		1126	int btf_check_type_match(struct bpf_verifier_env env, struct bpf_prog prog,
		1127	struct btf btf, const struct btf_type t);
		1128
		1129	struct bpf_prog *bpf_prog_by_id(u32 id);
945		1130
946	#else /* !CONFIG_BPF_SYSCALL */	1131	#else /* !CONFIG_BPF_SYSCALL */
947	static inline struct bpf_prog *bpf_prog_get(u32 ufd)	1132	static inline struct bpf_prog *bpf_prog_get(u32 ufd)
@@ -1004,13 +1189,20 @@ static inline struct net_device __dev_map_hash_lookup_elem(struct bpf_map map · 56 unmodified lines
1004	return NULL;	1189	return NULL;
1005	}	1190	}
1006		1191
1007	static inline void __dev_map_flush(struct bpf_map *map)	1192	static inline void __dev_flush(void)
1008	{	1193	{
1009	}	1194	}
1010		1195
1011	struct xdp_buff;	1196	struct xdp_buff;
1012	struct bpf_dtab_netdev;	1197	struct bpf_dtab_netdev;
1013		1198
		1199	static inline
		1200	int dev_xdp_enqueue(struct net_device dev, struct xdp_buff xdp,
		1201	struct net_device *dev_rx)
		1202	{
		1203	return 0;
		1204	}
		1205
1014	static inline	1206	static inline
1015	int dev_map_enqueue(struct bpf_dtab_netdev dst, struct xdp_buff xdp,	1207	int dev_map_enqueue(struct bpf_dtab_netdev dst, struct xdp_buff xdp,
1016	struct net_device *dev_rx)	1208	struct net_device *dev_rx)
@@ -1033,7 +1225,7 @@ struct bpf_cpu_map_entry __cpu_map_lookup_elem(struct bpf_map map, u32 key) · 16 unmodified lines
1033	return NULL;	1225	return NULL;
1034	}	1226	}
1035		1227
1036	static inline void __cpu_map_flush(struct bpf_map *map)	1228	static inline void __cpu_map_flush(void)
1037	{	1229	{
1038	}	1230	}
1039		1231
@@ -1074,6 +1266,11 @@ static inline int bpf_prog_test_run_flow_dissector(struct bpf_prog *prog, · 34 unmodified lines
1074	static inline void bpf_map_put(struct bpf_map *map)	1266	static inline void bpf_map_put(struct bpf_map *map)
1075	{	1267	{
1076	}	1268	}
		1269
		1270	static inline struct bpf_prog *bpf_prog_by_id(u32 id)
		1271	{
		1272	return ERR_PTR(-ENOTSUPP);
		1273	}
1077	#endif /* CONFIG_BPF_SYSCALL */	1274	#endif /* CONFIG_BPF_SYSCALL */
1078		1275
1079	static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,	1276	static inline struct bpf_prog *bpf_prog_get_type(u32 ufd,
@@ -1227,6 +1424,7 @@ extern const struct bpf_func_proto bpf_get_local_storage_proto; · 147 unmodified lines
1227	extern const struct bpf_func_proto bpf_strtol_proto;	1424	extern const struct bpf_func_proto bpf_strtol_proto;
1228	extern const struct bpf_func_proto bpf_strtoul_proto;	1425	extern const struct bpf_func_proto bpf_strtoul_proto;
1229	extern const struct bpf_func_proto bpf_tcp_sock_proto;	1426	extern const struct bpf_func_proto bpf_tcp_sock_proto;
		1427	extern const struct bpf_func_proto bpf_jiffies64_proto;
1230		1428
1231	/* Shared helpers among cBPF and eBPF. */	1429	/* Shared helpers among cBPF and eBPF. */
1232	void bpf_user_rnd_init_once(void);	1430	void bpf_user_rnd_init_once(void);

include/linux/bpf_types.h+9−0

 BPF_PROG_TYPE(BPF_PROG_TYPE_SK_REUSEPORT, sk_reuseport,
 	      struct sk_reuseport_md, struct sk_reuseport_kern)
 #endif
+#if defined(CONFIG_BPF_JIT)
+BPF_PROG_TYPE(BPF_PROG_TYPE_STRUCT_OPS, bpf_struct_ops,
+	      void *, void *)
+BPF_PROG_TYPE(BPF_PROG_TYPE_EXT, bpf_extension,
+	      void *, void *)
+#endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_ARRAY, percpu_array_map_ops)
 #endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_QUEUE, queue_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_STACK, stack_map_ops)
+#if defined(CONFIG_BPF_JIT)
+BPF_MAP_TYPE(BPF_MAP_TYPE_STRUCT_OPS, bpf_struct_ops_map_ops)
+#endif

include/linux/bpf_verifier.h+8−2

@@ -304,11 +304,13 @@ struct bpf_insn_aux_data { · 303 unmodified lines
304	u64 map_key_state; /* constant (32 bit) key tracking for maps */	304	u64 map_key_state; /* constant (32 bit) key tracking for maps */
305	int ctx_field_size; /* the ctx field size for load insn, maybe 0 */	305	int ctx_field_size; /* the ctx field size for load insn, maybe 0 */
306	int sanitize_stack_off; /* stack slot to be cleared */	306	int sanitize_stack_off; /* stack slot to be cleared */
307	bool seen; /* this insn was processed by the verifier */	307	u32 seen; /* this insn was processed by the verifier at env->pass_cnt */
308	bool zext_dst; /* this insn zero extends dst reg */	308	bool zext_dst; /* this insn zero extends dst reg */
309	u8 alu_state; /* used in combination with alu_limit */	309	u8 alu_state; /* used in combination with alu_limit */
310	bool prune_point;	310
		311	/* below fields are initialized once */
311	unsigned int orig_idx; /* original instruction index */	312	unsigned int orig_idx; /* original instruction index */
		313	bool prune_point;
312	};	314	};
313		315
314	#define MAX_USED_MAPS 64 /* max number of maps accessed by one eBPF program */	316	#define MAX_USED_MAPS 64 /* max number of maps accessed by one eBPF program */
@@ -379,6 +381,7 @@ struct bpf_verifier_env { · 64 unmodified lines
379	int *insn_stack;	381	int *insn_stack;
380	int cur_stack;	382	int cur_stack;
381	} cfg;	383	} cfg;
		384	u32 pass_cnt; /* number of times do_check() was called */
382	u32 subprog_cnt;	385	u32 subprog_cnt;
383	/* number of instructions analyzed by the verifier */	386	/* number of instructions analyzed by the verifier */
384	u32 prev_insn_processed, insn_processed;	387	u32 prev_insn_processed, insn_processed;
@@ -428,4 +431,7 @@ bpf_prog_offload_replace_insn(struct bpf_verifier_env *env, u32 off, · 43 unmodified lines
428	void	431	void
429	bpf_prog_offload_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt);	432	bpf_prog_offload_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt);
430		433
		434	int check_ctx_reg(struct bpf_verifier_env *env,
		435	const struct bpf_reg_state *reg, int regno);
		436
431	#endif /* _LINUX_BPF_VERIFIER_H */	437	#endif /* _LINUX_BPF_VERIFIER_H */

include/linux/btf.h+52−0

@@ -7,6 +7,8 @@ · 6 unmodified lines
7	#include <linux/types.h>	7	#include <linux/types.h>
8	#include <uapi/linux/btf.h>	8	#include <uapi/linux/btf.h>
9		9
		10	#define BTF_TYPE_EMIT(type) ((void)(type *)0)
		11
10	struct btf;	12	struct btf;
11	struct btf_member;	13	struct btf_member;
12	struct btf_type;	14	struct btf_type;
@@ -53,6 +55,22 @@ bool btf_member_is_reg_int(const struct btf btf, const struct btf_type s, · 40 unmodified lines
53	u32 expected_offset, u32 expected_size);	55	u32 expected_offset, u32 expected_size);
54	int btf_find_spin_lock(const struct btf btf, const struct btf_type t);	56	int btf_find_spin_lock(const struct btf btf, const struct btf_type t);
55	bool btf_type_is_void(const struct btf_type *t);	57	bool btf_type_is_void(const struct btf_type *t);
		58	s32 btf_find_by_name_kind(const struct btf btf, const char name, u8 kind);
		59	const struct btf_type btf_type_skip_modifiers(const struct btf btf,
		60	u32 id, u32 *res_id);
		61	const struct btf_type btf_type_resolve_ptr(const struct btf btf,
		62	u32 id, u32 *res_id);
		63	const struct btf_type btf_type_resolve_func_ptr(const struct btf btf,
		64	u32 id, u32 *res_id);
		65	const struct btf_type *
		66	btf_resolve_size(const struct btf btf, const struct btf_type type,
		67	u32 type_size, const struct btf_type *elem_type,
		68	u32 *total_nelems);
		69
		70	#define for_each_member(i, struct_type, member) \
		71	for (i = 0, member = btf_type_member(struct_type); \
		72	i < btf_type_vlen(struct_type); \
		73	i++, member++)
56		74
57	static inline bool btf_type_is_ptr(const struct btf_type *t)	75	static inline bool btf_type_is_ptr(const struct btf_type *t)
58	{	76	{
@@ -84,6 +102,40 @@ static inline bool btf_type_is_func_proto(const struct btf_type *t) · 25 unmodified lines
84	return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC_PROTO;	102	return BTF_INFO_KIND(t->info) == BTF_KIND_FUNC_PROTO;
85	}	103	}
86		104
		105	static inline u16 btf_type_vlen(const struct btf_type *t)
		106	{
		107	return BTF_INFO_VLEN(t->info);
		108	}
		109
		110	static inline u16 btf_func_linkage(const struct btf_type *t)
		111	{
		112	return BTF_INFO_VLEN(t->info);
		113	}
		114
		115	static inline bool btf_type_kflag(const struct btf_type *t)
		116	{
		117	return BTF_INFO_KFLAG(t->info);
		118	}
		119
		120	static inline u32 btf_member_bit_offset(const struct btf_type *struct_type,
		121	const struct btf_member *member)
		122	{
		123	return btf_type_kflag(struct_type) ? BTF_MEMBER_BIT_OFFSET(member->offset)
		124	: member->offset;
		125	}
		126
		127	static inline u32 btf_member_bitfield_size(const struct btf_type *struct_type,
		128	const struct btf_member *member)
		129	{
		130	return btf_type_kflag(struct_type) ? BTF_MEMBER_BITFIELD_SIZE(member->offset)
		131	: 0;
		132	}
		133
		134	static inline const struct btf_member btf_type_member(const struct btf_type t)
		135	{
		136	return (const struct btf_member *)(t + 1);
		137	}
		138
87	#ifdef CONFIG_BPF_SYSCALL	139	#ifdef CONFIG_BPF_SYSCALL
88	const struct btf_type btf_type_by_id(const struct btf btf, u32 type_id);	140	const struct btf_type btf_type_by_id(const struct btf btf, u32 type_id);
89	const char btf_name_by_offset(const struct btf btf, u32 offset);	141	const char btf_name_by_offset(const struct btf btf, u32 offset);

include/linux/dsa/sja1105.h+3−3

  * the structure defined in struct sja1105_private.
  */
 struct sja1105_tagger_data {
-	struct sk_buff_head skb_rxtstamp_queue;
-	struct work_struct rxtstamp_work;
 	struct sk_buff *stampable_skb;
 	/* Protects concurrent access to the meta state machine
 	 * from taggers running on multiple ports on SMP systems
 	((struct sja1105_skb_cb *)DSA_SKB_CB_PRIV(skb))
 struct sja1105_port {
+	struct kthread_worker *xmit_worker;
+	struct kthread_work xmit_work;
+	struct sk_buff_head xmit_queue;
 	struct sja1105_tagger_data *data;
 	struct dsa_port *dp;
 	bool hwts_tx_en;
-	int mgmt_slot;
 };
 #endif /* _NET_DSA_SJA1105_H */

include/linux/etherdevice.h+0−1

@@ -43,7 +43,6 @@ __be16 eth_header_parse_protocol(const struct sk_buff *skb); · 42 unmodified lines
43	int eth_prepare_mac_addr_change(struct net_device dev, void p);	43	int eth_prepare_mac_addr_change(struct net_device dev, void p);
44	void eth_commit_mac_addr_change(struct net_device dev, void p);	44	void eth_commit_mac_addr_change(struct net_device dev, void p);
45	int eth_mac_addr(struct net_device dev, void p);	45	int eth_mac_addr(struct net_device dev, void p);
46	int eth_change_mtu(struct net_device *dev, int new_mtu);
47	int eth_validate_addr(struct net_device *dev);	46	int eth_validate_addr(struct net_device *dev);
48		47
49	struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,	48	struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,

include/linux/ethtool_netlink.h+17−0

@@ -0,0 +1,17 @@
	1	/* SPDX-License-Identifier: GPL-2.0-only */
	2
	3	#ifndef _LINUX_ETHTOOL_NETLINK_H_
	4	#define _LINUX_ETHTOOL_NETLINK_H_
	5
	6	#include <uapi/linux/ethtool_netlink.h>
	7	#include <linux/ethtool.h>
	8	#include <linux/netdevice.h>
	9
	10	#define __ETHTOOL_LINK_MODE_MASK_NWORDS \
	11	DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)
	12
	13	enum ethtool_multicast_groups {
	14	ETHNL_MCGRP_MONITOR,
	15	};
	16
	17	#endif /* _LINUX_ETHTOOL_NETLINK_H_ */

include/linux/filter.h+34−19

 DECLARE_STATIC_KEY_FALSE(bpf_stats_enabled_key);
-#define BPF_PROG_RUN(prog, ctx)	({				\
+#define __BPF_PROG_RUN(prog, ctx, dfunc)	({			\
-	u32 ret;						\
+	u32 ret;							\
-	cant_sleep();						\
+	cant_sleep();							\
-	if (static_branch_unlikely(&bpf_stats_enabled_key)) {	\
+	if (static_branch_unlikely(&bpf_stats_enabled_key)) {		\
-		struct bpf_prog_stats *stats;			\
+		struct bpf_prog_stats *stats;				\
-		u64 start = sched_clock();			\
+		u64 start = sched_clock();				\
-		ret = (*(prog)->bpf_func)(ctx, (prog)->insnsi);	\
+		ret = dfunc(ctx, (prog)->insnsi, (prog)->bpf_func);	\
-		stats = this_cpu_ptr(prog->aux->stats);		\
+		stats = this_cpu_ptr(prog->aux->stats);			\
-		u64_stats_update_begin(&stats->syncp);		\
+		u64_stats_update_begin(&stats->syncp);			\
-		stats->cnt++;					\
+		stats->cnt++;						\
-		stats->nsecs += sched_clock() - start;		\
+		stats->nsecs += sched_clock() - start;			\
-		u64_stats_update_end(&stats->syncp);		\
+		u64_stats_update_end(&stats->syncp);			\
-	} else {						\
+	} else {							\
-		ret = (*(prog)->bpf_func)(ctx, (prog)->insnsi);	\
+		ret = dfunc(ctx, (prog)->insnsi, (prog)->bpf_func);	\
-	}							\
+	}								\
 	ret; })
+#define BPF_PROG_RUN(prog, ctx) __BPF_PROG_RUN(prog, ctx,		\
+					       bpf_dispatcher_nopfunc)
 #define BPF_SKB_CB_LEN QDISC_CB_PRIV_LEN
 struct bpf_skb_data_end {
 	u32 tgt_index;
 	void *tgt_value;
 	struct bpf_map *map;
-	struct bpf_map *map_to_flush;
 	u32 kern_flags;
 };
 	return res;
 }
+DECLARE_BPF_DISPATCHER(bpf_dispatcher_xdp)
 static __always_inline u32 bpf_prog_run_xdp(const struct bpf_prog *prog,
 					    struct xdp_buff *xdp)
 {
 	 * already takes rcu_read_lock() when fetching the program, so
 	 * it's not necessary here anymore.
 	 */
-	return BPF_PROG_RUN(prog, xdp);
+	return __BPF_PROG_RUN(prog, xdp,
+			      BPF_DISPATCHER_FUNC(bpf_dispatcher_xdp));
 }
+void bpf_prog_change_xdp(struct bpf_prog *prev_prog, struct bpf_prog *prog);
 static inline u32 bpf_prog_insn_size(const struct bpf_prog *prog)
 {
 	return prog->len * sizeof(struct bpf_insn);
 int bpf_prog_create_from_user(struct bpf_prog **pfp, struct sock_fprog *fprog,
 			      bpf_aux_classic_check_t trans, bool save_orig);
 void bpf_prog_destroy(struct bpf_prog *fp);
+const struct bpf_func_proto *
+bpf_base_func_proto(enum bpf_func_id func_id);
 int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 int sk_attach_bpf(u32 ufd, struct sock *sk);
 	return 0;
 }
-/* The pair of xdp_do_redirect and xdp_do_flush_map MUST be called in the
+/* The pair of xdp_do_redirect and xdp_do_flush MUST be called in the
  * same cpu context. Further for best results no more than a single map
  * for the do_redirect/do_flush pair should be used. This limitation is
  * because we only track one map and force a flush when the map changes.
 int xdp_do_redirect(struct net_device *dev,
 		    struct xdp_buff *xdp,
 		    struct bpf_prog *prog);
-void xdp_do_flush_map(void);
+void xdp_do_flush(void);
+/* The xdp_do_flush_map() helper has been renamed to drop the _map suffix, as
+ * it is no longer only flushing maps. Keep this define for compatibility
+ * until all drivers are updated - do not use xdp_do_flush_map() in new code!
+ */
+#define xdp_do_flush_map xdp_do_flush
 void bpf_warn_invalid_xdp_action(u32 act);

include/linux/fsl/enetc_mdio.h+55−0

@@ -0,0 +1,55 @@
	1	/* SPDX-License-Identifier: (GPL-2.0+ OR BSD-3-Clause) */
	2	/* Copyright 2019 NXP */
	3
	4	#ifndef _FSL_ENETC_MDIO_H_
	5	#define _FSL_ENETC_MDIO_H_
	6
	7	#include <linux/phy.h>
	8
	9	/* PCS registers */
	10	#define ENETC_PCS_LINK_TIMER1 0x12
	11	#define ENETC_PCS_LINK_TIMER1_VAL 0x06a0
	12	#define ENETC_PCS_LINK_TIMER2 0x13
	13	#define ENETC_PCS_LINK_TIMER2_VAL 0x0003
	14	#define ENETC_PCS_IF_MODE 0x14
	15	#define ENETC_PCS_IF_MODE_SGMII_EN BIT(0)
	16	#define ENETC_PCS_IF_MODE_USE_SGMII_AN BIT(1)
	17	#define ENETC_PCS_IF_MODE_SGMII_SPEED(x) (((x) << 2) & GENMASK(3, 2))
	18
	19	/* Not a mistake, the SerDes PLL needs to be set at 3.125 GHz by Reset
	20	* Configuration Word (RCW, outside Linux control) for 2.5G SGMII mode. The PCS
	21	* still thinks it's at gigabit.
	22	*/
	23	enum enetc_pcs_speed {
	24	ENETC_PCS_SPEED_10 = 0,
	25	ENETC_PCS_SPEED_100 = 1,
	26	ENETC_PCS_SPEED_1000 = 2,
	27	ENETC_PCS_SPEED_2500 = 2,
	28	};
	29
	30	struct enetc_hw;
	31
	32	struct enetc_mdio_priv {
	33	struct enetc_hw *hw;
	34	int mdio_base;
	35	};
	36
	37	#if IS_REACHABLE(CONFIG_FSL_ENETC_MDIO)
	38
	39	int enetc_mdio_read(struct mii_bus *bus, int phy_id, int regnum);
	40	int enetc_mdio_write(struct mii_bus *bus, int phy_id, int regnum, u16 value);
	41	struct enetc_hw enetc_hw_alloc(struct device dev, void __iomem *port_regs);
	42
	43	#else
	44
	45	static inline int enetc_mdio_read(struct mii_bus *bus, int phy_id, int regnum)
	46	{ return -EINVAL; }
	47	static inline int enetc_mdio_write(struct mii_bus *bus, int phy_id, int regnum,
	48	u16 value)
	49	{ return -EINVAL; }
	50	struct enetc_hw enetc_hw_alloc(struct device dev, void __iomem *port_regs)
	51	{ return ERR_PTR(-EINVAL); }
	52
	53	#endif
	54
	55	#endif

include/linux/fsl/ptp_qoriq.h+1−0

@@ -192,6 +192,7 @@ int ptp_qoriq_settime(struct ptp_clock_info *ptp, · 191 unmodified lines
192	const struct timespec64 *ts);	192	const struct timespec64 *ts);
193	int ptp_qoriq_enable(struct ptp_clock_info *ptp,	193	int ptp_qoriq_enable(struct ptp_clock_info *ptp,
194	struct ptp_clock_request *rq, int on);	194	struct ptp_clock_request *rq, int on);
		195	int extts_clean_up(struct ptp_qoriq *ptp_qoriq, int index, bool update_event);
195	#ifdef CONFIG_DEBUG_FS	196	#ifdef CONFIG_DEBUG_FS
196	void ptp_qoriq_create_debugfs(struct ptp_qoriq *ptp_qoriq);	197	void ptp_qoriq_create_debugfs(struct ptp_qoriq *ptp_qoriq);
197	void ptp_qoriq_remove_debugfs(struct ptp_qoriq *ptp_qoriq);	198	void ptp_qoriq_remove_debugfs(struct ptp_qoriq *ptp_qoriq);

include/linux/mii.h+50−0

@@ -372,6 +372,56 @@ static inline u32 mii_lpa_to_ethtool_lpa_x(u32 lpa) · 371 unmodified lines
372	return result \| mii_adv_to_ethtool_adv_x(lpa);	372	return result \| mii_adv_to_ethtool_adv_x(lpa);
373	}	373	}
374		374
		375	/**
		376	* mii_lpa_mod_linkmode_adv_sgmii
		377	* @lp_advertising: pointer to destination link mode.
		378	* @lpa: value of the MII_LPA register
		379	*
		380	* A small helper function that translates MII_LPA bits to
		381	* linkmode advertisement settings for SGMII.
		382	* Leaves other bits unchanged.
		383	*/
		384	static inline void
		385	mii_lpa_mod_linkmode_lpa_sgmii(unsigned long *lp_advertising, u32 lpa)
		386	{
		387	u32 speed_duplex = lpa & LPA_SGMII_DPX_SPD_MASK;
		388
		389	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT, lp_advertising,
		390	speed_duplex == LPA_SGMII_1000HALF);
		391
		392	linkmode_mod_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, lp_advertising,
		393	speed_duplex == LPA_SGMII_1000FULL);
		394
		395	linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, lp_advertising,
		396	speed_duplex == LPA_SGMII_100HALF);
		397
		398	linkmode_mod_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, lp_advertising,
		399	speed_duplex == LPA_SGMII_100FULL);
		400
		401	linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, lp_advertising,
		402	speed_duplex == LPA_SGMII_10HALF);
		403
		404	linkmode_mod_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, lp_advertising,
		405	speed_duplex == LPA_SGMII_10FULL);
		406	}
		407
		408	/**
		409	* mii_lpa_to_linkmode_adv_sgmii
		410	* @advertising: pointer to destination link mode.
		411	* @lpa: value of the MII_LPA register
		412	*
		413	* A small helper function that translates MII_ADVERTISE bits
		414	* to linkmode advertisement settings when in SGMII mode.
		415	* Clears the old value of advertising.
		416	*/
		417	static inline void mii_lpa_to_linkmode_lpa_sgmii(unsigned long *lp_advertising,
		418	u32 lpa)
		419	{
		420	linkmode_zero(lp_advertising);
		421
		422	mii_lpa_mod_linkmode_lpa_sgmii(lp_advertising, lpa);
		423	}
		424
375	/**	425	/**
376	* mii_adv_mod_linkmode_adv_t	426	* mii_adv_mod_linkmode_adv_t
377	* @advertising:pointer to destination link mode.	427	* @advertising:pointer to destination link mode.

include/linux/mii_timestamper.h+121−0

@@ -0,0 +1,121 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Support for generic time stamping devices on MII buses.
	4	* Copyright (C) 2018 Richard Cochran <richardcochran@gmail.com>
	5	*/
	6	#ifndef _LINUX_MII_TIMESTAMPER_H
	7	#define _LINUX_MII_TIMESTAMPER_H
	8
	9	#include <linux/device.h>
	10	#include <linux/ethtool.h>
	11	#include <linux/skbuff.h>
	12
	13	struct phy_device;
	14
	15	/**
	16	* struct mii_timestamper - Callback interface to MII time stamping devices.
	17	*
	18	* @rxtstamp: Requests a Rx timestamp for 'skb'. If the skb is accepted,
	19	* the MII time stamping device promises to deliver it using
	20	* netif_rx() as soon as a timestamp becomes available. One of
	21	* the PTP_CLASS_ values is passed in 'type'. The function
	22	* must return true if the skb is accepted for delivery.
	23	*
	24	* @txtstamp: Requests a Tx timestamp for 'skb'. The MII time stamping
	25	* device promises to deliver it using skb_complete_tx_timestamp()
	26	* as soon as a timestamp becomes available. One of the PTP_CLASS_
	27	* values is passed in 'type'.
	28	*
	29	* @hwtstamp: Handles SIOCSHWTSTAMP ioctl for hardware time stamping.
	30	*
	31	* @link_state: Allows the device to respond to changes in the link
	32	* state. The caller invokes this function while holding
	33	* the phy_device mutex.
	34	*
	35	* @ts_info: Handles ethtool queries for hardware time stamping.
	36	* @device: Remembers the device to which the instance belongs.
	37	*
	38	* Drivers for PHY time stamping devices should embed their
	39	* mii_timestamper within a private structure, obtaining a reference
	40	* to it using container_of().
	41	*
	42	* Drivers for non-PHY time stamping devices should return a pointer
	43	* to a mii_timestamper from the probe_channel() callback of their
	44	* mii_timestamping_ctrl interface.
	45	*/
	46	struct mii_timestamper {
	47	bool (rxtstamp)(struct mii_timestamper mii_ts,
	48	struct sk_buff *skb, int type);
	49
	50	void (txtstamp)(struct mii_timestamper mii_ts,
	51	struct sk_buff *skb, int type);
	52
	53	int (hwtstamp)(struct mii_timestamper mii_ts,
	54	struct ifreq *ifreq);
	55
	56	void (link_state)(struct mii_timestamper mii_ts,
	57	struct phy_device *phydev);
	58
	59	int (ts_info)(struct mii_timestamper mii_ts,
	60	struct ethtool_ts_info *ts_info);
	61
	62	struct device *device;
	63	};
	64
	65	/**
	66	* struct mii_timestamping_ctrl - MII time stamping controller interface.
	67	*
	68	* @probe_channel: Callback into the controller driver announcing the
	69	* presence of the 'port' channel. The 'device' field
	70	* had been passed to register_mii_tstamp_controller().
	71	* The driver must return either a pointer to a valid
	72	* MII timestamper instance or PTR_ERR.
	73	*
	74	* @release_channel: Releases an instance obtained via .probe_channel.
	75	*/
	76	struct mii_timestamping_ctrl {
	77	struct mii_timestamper (probe_channel)(struct device *device,
	78	unsigned int port);
	79	void (release_channel)(struct device device,
	80	struct mii_timestamper *mii_ts);
	81	};
	82
	83	#ifdef CONFIG_NETWORK_PHY_TIMESTAMPING
	84
	85	int register_mii_tstamp_controller(struct device *device,
	86	struct mii_timestamping_ctrl *ctrl);
	87
	88	void unregister_mii_tstamp_controller(struct device *device);
	89
	90	struct mii_timestamper register_mii_timestamper(struct device_node node,
	91	unsigned int port);
	92
	93	void unregister_mii_timestamper(struct mii_timestamper *mii_ts);
	94
	95	#else
	96
	97	static inline
	98	int register_mii_tstamp_controller(struct device *device,
	99	struct mii_timestamping_ctrl *ctrl)
	100	{
	101	return -EOPNOTSUPP;
	102	}
	103
	104	static inline void unregister_mii_tstamp_controller(struct device *device)
	105	{
	106	}
	107
	108	static inline
	109	struct mii_timestamper register_mii_timestamper(struct device_node node,
	110	unsigned int port)
	111	{
	112	return NULL;
	113	}
	114
	115	static inline void unregister_mii_timestamper(struct mii_timestamper *mii_ts)
	116	{
	117	}
	118
	119	#endif
	120
	121	#endif

include/linux/mlx4/device.h+1−1

@@ -47,7 +47,7 @@ · 46 unmodified lines
47	#define DEFAULT_UAR_PAGE_SHIFT 12	47	#define DEFAULT_UAR_PAGE_SHIFT 12
48		48
49	#define MAX_MSIX_P_PORT 17	49	#define MAX_MSIX_P_PORT 17
50	#define MAX_MSIX 64	50	#define MAX_MSIX 128
51	#define MIN_MSIX_P_PORT 5	51	#define MIN_MSIX_P_PORT 5
52	#define MLX4_IS_LEGACY_EQ_MODE(dev_cap) ((dev_cap).num_comp_vectors < \	52	#define MLX4_IS_LEGACY_EQ_MODE(dev_cap) ((dev_cap).num_comp_vectors < \
53	(dev_cap).num_ports * MIN_MSIX_P_PORT)	53	(dev_cap).num_ports * MIN_MSIX_P_PORT)

include/linux/mlx5/device.h+22−1

 	MLX5_CAP_DEV_MEM,
 	MLX5_CAP_RESERVED_16,
 	MLX5_CAP_TLS,
+	MLX5_CAP_VDPA_EMULATION = 0x13,
 	MLX5_CAP_DEV_EVENT = 0x14,
 	/* NUM OF CAP Types */
 	MLX5_CAP_NUM
 enum mlx5_mcam_reg_groups {
 	MLX5_MCAM_REGS_FIRST_128                    = 0x0,
+	MLX5_MCAM_REGS_0x9080_0x90FF                = 0x1,
+	MLX5_MCAM_REGS_0x9100_0x917F                = 0x2,
+	MLX5_MCAM_REGS_NUM                          = 0x3,
 };
 enum mlx5_mcam_feature_groups {
 	MLX5_GET(pcam_reg, (mdev)->caps.pcam, port_access_reg_cap_mask.regs_5000_to_507f.reg)
 #define MLX5_CAP_MCAM_REG(mdev, reg) \
-	MLX5_GET(mcam_reg, (mdev)->caps.mcam, mng_access_reg_cap_mask.access_regs.reg)
+	MLX5_GET(mcam_reg, (mdev)->caps.mcam[MLX5_MCAM_REGS_FIRST_128], \
+		 mng_access_reg_cap_mask.access_regs.reg)
+#define MLX5_CAP_MCAM_REG1(mdev, reg) \
+	MLX5_GET(mcam_reg, (mdev)->caps.mcam[MLX5_MCAM_REGS_0x9080_0x90FF], \
+		 mng_access_reg_cap_mask.access_regs1.reg)
+#define MLX5_CAP_MCAM_REG2(mdev, reg) \
+	MLX5_GET(mcam_reg, (mdev)->caps.mcam[MLX5_MCAM_REGS_0x9100_0x917F], \
+		 mng_access_reg_cap_mask.access_regs2.reg)
 #define MLX5_CAP_MCAM_FEATURE(mdev, fld) \
 	MLX5_GET(mcam_reg, (mdev)->caps.mcam, mng_feature_cap_mask.enhanced_features.fld)
 #define MLX5_CAP_DEV_EVENT(mdev, cap)\
 	MLX5_ADDR_OF(device_event_cap, (mdev)->caps.hca_cur[MLX5_CAP_DEV_EVENT], cap)
+#define MLX5_CAP_DEV_VDPA_EMULATION(mdev, cap)\
+	MLX5_GET(device_virtio_emulation_cap, \
+		(mdev)->caps.hca_cur[MLX5_CAP_VDPA_EMULATION], cap)
+#define MLX5_CAP64_DEV_VDPA_EMULATION(mdev, cap)\
+	MLX5_GET64(device_virtio_emulation_cap, \
+		(mdev)->caps.hca_cur[MLX5_CAP_VDPA_EMULATION], cap)
 enum {
 	MLX5_CMD_STAT_OK			= 0x0,
 	MLX5_CMD_STAT_INT_ERR			= 0x1,

include/linux/mlx5/driver.h+3−3

 	MLX5_REG_MCC		 = 0x9062,
 	MLX5_REG_MCDA		 = 0x9063,
 	MLX5_REG_MCAM		 = 0x907f,
+	MLX5_REG_MIRC		 = 0x9162,
+	MLX5_REG_RESOURCE_DUMP   = 0xC000,
 };
 enum mlx5_qpts_trust_state {
 		u32 hca_cur[MLX5_CAP_NUM][MLX5_UN_SZ_DW(hca_cap_union)];
 		u32 hca_max[MLX5_CAP_NUM][MLX5_UN_SZ_DW(hca_cap_union)];
 		u32 pcam[MLX5_ST_SZ_DW(pcam_reg)];
-		u32 mcam[MLX5_ST_SZ_DW(mcam_reg)];
+		u32 mcam[MLX5_MCAM_REGS_NUM][MLX5_ST_SZ_DW(mcam_reg)];
 		u32 fpga[MLX5_ST_SZ_DW(fpga_cap)];
 		u32 qcam[MLX5_ST_SZ_DW(qcam_reg)];
 		u8  embedded_cpu;
 void mlx5_stop_health_poll(struct mlx5_core_dev *dev, bool disable_health);
 void mlx5_drain_health_wq(struct mlx5_core_dev *dev);
 void mlx5_trigger_health_work(struct mlx5_core_dev *dev);
-int mlx5_buf_alloc_node(struct mlx5_core_dev *dev, int size,
-			struct mlx5_frag_buf *buf, int node);
 int mlx5_buf_alloc(struct mlx5_core_dev *dev,
 		   int size, struct mlx5_frag_buf *buf);
 void mlx5_buf_free(struct mlx5_core_dev *dev, struct mlx5_frag_buf *buf);

include/linux/mlx5/fs.h+12−8

 	MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT = BIT(0),
 	MLX5_FLOW_TABLE_TUNNEL_EN_DECAP = BIT(1),
 	MLX5_FLOW_TABLE_TERMINATION = BIT(2),
+	MLX5_FLOW_TABLE_UNMANAGED = BIT(3),
 };
 #define LEFTOVERS_RULE_NUM	 2
 				  enum mlx5_flow_namespace_type type,
 				  int vport);
-struct mlx5_flow_table *
-mlx5_create_auto_grouped_flow_table(struct mlx5_flow_namespace *ns,
-				    int prio,
-				    int num_flow_table_entries,
-				    int max_num_groups,
-				    u32 level,
-				    u32 flags);
 struct mlx5_flow_table_attr {
 	int prio;
 	int max_fte;
 	u32 level;
 	u32 flags;
+	struct mlx5_flow_table *next_ft;
+	struct {
+		int max_num_groups;
+		int num_reserved_entries;
+	} autogroup;
 };
 struct mlx5_flow_table *
 mlx5_create_flow_table(struct mlx5_flow_namespace *ns,
 		       struct mlx5_flow_table_attr *ft_attr);
+struct mlx5_flow_table *
+mlx5_create_auto_grouped_flow_table(struct mlx5_flow_namespace *ns,
+				    struct mlx5_flow_table_attr *ft_attr);
 struct mlx5_flow_table *
 mlx5_create_vport_flow_table(struct mlx5_flow_namespace *ns,
 			     int prio,
 enum {
 	FLOW_ACT_NO_APPEND = BIT(0),
+	FLOW_ACT_IGNORE_FLOW_LEVEL = BIT(1),
 };
 struct mlx5_flow_act {

include/linux/mlx5/mlx5_ifc.h+230−7

@@ -87,6 +87,7 @@ enum { · 86 unmodified lines
87	enum {	87	enum {
88	MLX5_GENERAL_OBJ_TYPES_CAP_SW_ICM = (1ULL << MLX5_OBJ_TYPE_SW_ICM),	88	MLX5_GENERAL_OBJ_TYPES_CAP_SW_ICM = (1ULL << MLX5_OBJ_TYPE_SW_ICM),
89	MLX5_GENERAL_OBJ_TYPES_CAP_GENEVE_TLV_OPT = (1ULL << 11),	89	MLX5_GENERAL_OBJ_TYPES_CAP_GENEVE_TLV_OPT = (1ULL << 11),
		90	MLX5_GENERAL_OBJ_TYPES_CAP_VIRTIO_NET_Q = (1ULL << 13),
90	};	91	};
91		92
92	enum {	93	enum {
@@ -374,8 +375,17 @@ struct mlx5_ifc_flow_table_fields_supported_bits { · 281 unmodified lines
374	u8 outer_esp_spi[0x1];	375	u8 outer_esp_spi[0x1];
375	u8 reserved_at_58[0x2];	376	u8 reserved_at_58[0x2];
376	u8 bth_dst_qp[0x1];	377	u8 bth_dst_qp[0x1];
		378	u8 reserved_at_5b[0x5];
377		379
378	u8 reserved_at_5b[0x25];	380	u8 reserved_at_60[0x18];
		381	u8 metadata_reg_c_7[0x1];
		382	u8 metadata_reg_c_6[0x1];
		383	u8 metadata_reg_c_5[0x1];
		384	u8 metadata_reg_c_4[0x1];
		385	u8 metadata_reg_c_3[0x1];
		386	u8 metadata_reg_c_2[0x1];
		387	u8 metadata_reg_c_1[0x1];
		388	u8 metadata_reg_c_0[0x1];
379	};	389	};
380		390
381	struct mlx5_ifc_flow_table_prop_layout_bits {	391	struct mlx5_ifc_flow_table_prop_layout_bits {
@@ -400,7 +410,8 @@ struct mlx5_ifc_flow_table_prop_layout_bits { · 18 unmodified lines
400	u8 reformat_l3_tunnel_to_l2[0x1];	410	u8 reformat_l3_tunnel_to_l2[0x1];
401	u8 reformat_l2_to_l3_tunnel[0x1];	411	u8 reformat_l2_to_l3_tunnel[0x1];
402	u8 reformat_and_modify_action[0x1];	412	u8 reformat_and_modify_action[0x1];
403	u8 reserved_at_15[0x2];	413	u8 ignore_flow_level[0x1];
		414	u8 reserved_at_16[0x1];
404	u8 table_miss_action_domain[0x1];	415	u8 table_miss_action_domain[0x1];
405	u8 termination_table[0x1];	416	u8 termination_table[0x1];
406	u8 reserved_at_19[0x7];	417	u8 reserved_at_19[0x7];
@@ -721,7 +732,9 @@ enum { · 314 unmodified lines
721		732
722	struct mlx5_ifc_flow_table_eswitch_cap_bits {	733	struct mlx5_ifc_flow_table_eswitch_cap_bits {
723	u8 fdb_to_vport_reg_c_id[0x8];	734	u8 fdb_to_vport_reg_c_id[0x8];
724	u8 reserved_at_8[0xf];	735	u8 reserved_at_8[0xd];
		736	u8 fdb_modify_header_fwd_to_table[0x1];
		737	u8 reserved_at_16[0x1];
725	u8 flow_source[0x1];	738	u8 flow_source[0x1];
726	u8 reserved_at_18[0x2];	739	u8 reserved_at_18[0x2];
727	u8 multi_fdb_encap[0x1];	740	u8 multi_fdb_encap[0x1];
@@ -822,7 +835,9 @@ struct mlx5_ifc_qos_cap_bits { · 94 unmodified lines
822	struct mlx5_ifc_debug_cap_bits {	835	struct mlx5_ifc_debug_cap_bits {
823	u8 core_dump_general[0x1];	836	u8 core_dump_general[0x1];
824	u8 core_dump_qp[0x1];	837	u8 core_dump_qp[0x1];
825	u8 reserved_at_2[0x1e];	838	u8 reserved_at_2[0x7];
		839	u8 resource_dump[0x1];
		840	u8 reserved_at_a[0x16];
826		841
827	u8 reserved_at_20[0x2];	842	u8 reserved_at_20[0x2];
828	u8 stall_detect[0x1];	843	u8 stall_detect[0x1];
@@ -953,6 +968,19 @@ struct mlx5_ifc_device_event_cap_bits { · 124 unmodified lines
953	u8 user_unaffiliated_events[4][0x40];	968	u8 user_unaffiliated_events[4][0x40];
954	};	969	};
955		970
		971	struct mlx5_ifc_device_virtio_emulation_cap_bits {
		972	u8 reserved_at_0[0x20];
		973
		974	u8 reserved_at_20[0x13];
		975	u8 log_doorbell_stride[0x5];
		976	u8 reserved_at_38[0x3];
		977	u8 log_doorbell_bar_size[0x5];
		978
		979	u8 doorbell_bar_offset[0x40];
		980
		981	u8 reserved_at_80[0x780];
		982	};
		983
956	enum {	984	enum {
957	MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_1_BYTE = 0x0,	985	MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_1_BYTE = 0x0,
958	MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_2_BYTES = 0x2,	986	MLX5_ATOMIC_CAPS_ATOMIC_SIZE_QP_2_BYTES = 0x2,
@@ -1753,6 +1781,132 @@ struct mlx5_ifc_resize_field_select_bits { · 794 unmodified lines
1753	u8 resize_field_select[0x20];	1781	u8 resize_field_select[0x20];
1754	};	1782	};
1755		1783
		1784	struct mlx5_ifc_resource_dump_bits {
		1785	u8 more_dump[0x1];
		1786	u8 inline_dump[0x1];
		1787	u8 reserved_at_2[0xa];
		1788	u8 seq_num[0x4];
		1789	u8 segment_type[0x10];
		1790
		1791	u8 reserved_at_20[0x10];
		1792	u8 vhca_id[0x10];
		1793
		1794	u8 index1[0x20];
		1795
		1796	u8 index2[0x20];
		1797
		1798	u8 num_of_obj1[0x10];
		1799	u8 num_of_obj2[0x10];
		1800
		1801	u8 reserved_at_a0[0x20];
		1802
		1803	u8 device_opaque[0x40];
		1804
		1805	u8 mkey[0x20];
		1806
		1807	u8 size[0x20];
		1808
		1809	u8 address[0x40];
		1810
		1811	u8 inline_data[52][0x20];
		1812	};
		1813
		1814	struct mlx5_ifc_resource_dump_menu_record_bits {
		1815	u8 reserved_at_0[0x4];
		1816	u8 num_of_obj2_supports_active[0x1];
		1817	u8 num_of_obj2_supports_all[0x1];
		1818	u8 must_have_num_of_obj2[0x1];
		1819	u8 support_num_of_obj2[0x1];
		1820	u8 num_of_obj1_supports_active[0x1];
		1821	u8 num_of_obj1_supports_all[0x1];
		1822	u8 must_have_num_of_obj1[0x1];
		1823	u8 support_num_of_obj1[0x1];
		1824	u8 must_have_index2[0x1];
		1825	u8 support_index2[0x1];
		1826	u8 must_have_index1[0x1];
		1827	u8 support_index1[0x1];
		1828	u8 segment_type[0x10];
		1829
		1830	u8 segment_name[4][0x20];
		1831
		1832	u8 index1_name[4][0x20];
		1833
		1834	u8 index2_name[4][0x20];
		1835	};
		1836
		1837	struct mlx5_ifc_resource_dump_segment_header_bits {
		1838	u8 length_dw[0x10];
		1839	u8 segment_type[0x10];
		1840	};
		1841
		1842	struct mlx5_ifc_resource_dump_command_segment_bits {
		1843	struct mlx5_ifc_resource_dump_segment_header_bits segment_header;
		1844
		1845	u8 segment_called[0x10];
		1846	u8 vhca_id[0x10];
		1847
		1848	u8 index1[0x20];
		1849
		1850	u8 index2[0x20];
		1851
		1852	u8 num_of_obj1[0x10];
		1853	u8 num_of_obj2[0x10];
		1854	};
		1855
		1856	struct mlx5_ifc_resource_dump_error_segment_bits {
		1857	struct mlx5_ifc_resource_dump_segment_header_bits segment_header;
		1858
		1859	u8 reserved_at_20[0x10];
		1860	u8 syndrome_id[0x10];
		1861
		1862	u8 reserved_at_40[0x40];
		1863
		1864	u8 error[8][0x20];
		1865	};
		1866
		1867	struct mlx5_ifc_resource_dump_info_segment_bits {
		1868	struct mlx5_ifc_resource_dump_segment_header_bits segment_header;
		1869
		1870	u8 reserved_at_20[0x18];
		1871	u8 dump_version[0x8];
		1872
		1873	u8 hw_version[0x20];
		1874
		1875	u8 fw_version[0x20];
		1876	};
		1877
		1878	struct mlx5_ifc_resource_dump_menu_segment_bits {
		1879	struct mlx5_ifc_resource_dump_segment_header_bits segment_header;
		1880
		1881	u8 reserved_at_20[0x10];
		1882	u8 num_of_records[0x10];
		1883
		1884	struct mlx5_ifc_resource_dump_menu_record_bits record[0];
		1885	};
		1886
		1887	struct mlx5_ifc_resource_dump_resource_segment_bits {
		1888	struct mlx5_ifc_resource_dump_segment_header_bits segment_header;
		1889
		1890	u8 reserved_at_20[0x20];
		1891
		1892	u8 index1[0x20];
		1893
		1894	u8 index2[0x20];
		1895
		1896	u8 payload[0][0x20];
		1897	};
		1898
		1899	struct mlx5_ifc_resource_dump_terminate_segment_bits {
		1900	struct mlx5_ifc_resource_dump_segment_header_bits segment_header;
		1901	};
		1902
		1903	struct mlx5_ifc_menu_resource_dump_response_bits {
		1904	struct mlx5_ifc_resource_dump_info_segment_bits info;
		1905	struct mlx5_ifc_resource_dump_command_segment_bits cmd;
		1906	struct mlx5_ifc_resource_dump_menu_segment_bits menu;
		1907	struct mlx5_ifc_resource_dump_terminate_segment_bits terminate;
		1908	};
		1909
1756	enum {	1910	enum {
1757	MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_PERIOD = 0x1,	1911	MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_PERIOD = 0x1,
1758	MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_MAX_COUNT = 0x2,	1912	MLX5_MODIFY_FIELD_SELECT_MODIFY_FIELD_SELECT_CQ_MAX_COUNT = 0x2,
@@ -2026,7 +2180,9 @@ struct mlx5_ifc_eth_per_prio_grp_data_layout_bits { · 267 unmodified lines
2026		2180
2027	u8 rx_pause_transition_low[0x20];	2181	u8 rx_pause_transition_low[0x20];
2028		2182
2029	u8 reserved_at_3c0[0x40];	2183	u8 rx_discards_high[0x20];
		2184
		2185	u8 rx_discards_low[0x20];
2030		2186
2031	u8 device_stall_minor_watermark_cnt_high[0x20];	2187	u8 device_stall_minor_watermark_cnt_high[0x20];
2032		2188
@@ -2751,6 +2907,7 @@ union mlx5_ifc_hca_cap_union_bits { · 718 unmodified lines
2751	struct mlx5_ifc_fpga_cap_bits fpga_cap;	2907	struct mlx5_ifc_fpga_cap_bits fpga_cap;
2752	struct mlx5_ifc_tls_cap_bits tls_cap;	2908	struct mlx5_ifc_tls_cap_bits tls_cap;
2753	struct mlx5_ifc_device_mem_cap_bits device_mem_cap;	2909	struct mlx5_ifc_device_mem_cap_bits device_mem_cap;
		2910	struct mlx5_ifc_device_virtio_emulation_cap_bits virtio_emulation_cap;
2754	u8 reserved_at_0[0x8000];	2911	u8 reserved_at_0[0x8000];
2755	};	2912	};
2756		2913
@@ -3998,7 +4155,8 @@ struct mlx5_ifc_set_fte_in_bits { · 1241 unmodified lines
3998	u8 reserved_at_a0[0x8];	4155	u8 reserved_at_a0[0x8];
3999	u8 table_id[0x18];	4156	u8 table_id[0x18];
4000		4157
4001	u8 reserved_at_c0[0x18];	4158	u8 ignore_flow_level[0x1];
		4159	u8 reserved_at_c1[0x17];
4002	u8 modify_enable_mask[0x8];	4160	u8 modify_enable_mask[0x8];
4003		4161
4004	u8 reserved_at_e0[0x20];	4162	u8 reserved_at_e0[0x20];
@@ -5466,15 +5624,32 @@ struct mlx5_ifc_add_action_in_bits { · 1461 unmodified lines
5466	u8 data[0x20];	5624	u8 data[0x20];
5467	};	5625	};
5468		5626
		5627	struct mlx5_ifc_copy_action_in_bits {
		5628	u8 action_type[0x4];
		5629	u8 src_field[0xc];
		5630	u8 reserved_at_10[0x3];
		5631	u8 src_offset[0x5];
		5632	u8 reserved_at_18[0x3];
		5633	u8 length[0x5];
		5634
		5635	u8 reserved_at_20[0x4];
		5636	u8 dst_field[0xc];
		5637	u8 reserved_at_30[0x3];
		5638	u8 dst_offset[0x5];
		5639	u8 reserved_at_38[0x8];
		5640	};
		5641
5469	union mlx5_ifc_set_action_in_add_action_in_auto_bits {	5642	union mlx5_ifc_set_action_in_add_action_in_auto_bits {
5470	struct mlx5_ifc_set_action_in_bits set_action_in;	5643	struct mlx5_ifc_set_action_in_bits set_action_in;
5471	struct mlx5_ifc_add_action_in_bits add_action_in;	5644	struct mlx5_ifc_add_action_in_bits add_action_in;
		5645	struct mlx5_ifc_copy_action_in_bits copy_action_in;
5472	u8 reserved_at_0[0x40];	5646	u8 reserved_at_0[0x40];
5473	};	5647	};
5474		5648
5475	enum {	5649	enum {
5476	MLX5_ACTION_TYPE_SET = 0x1,	5650	MLX5_ACTION_TYPE_SET = 0x1,
5477	MLX5_ACTION_TYPE_ADD = 0x2,	5651	MLX5_ACTION_TYPE_ADD = 0x2,
		5652	MLX5_ACTION_TYPE_COPY = 0x3,
5478	};	5653	};
5479		5654
5480	enum {	5655	enum {
@@ -5510,6 +5685,8 @@ enum { · 29 unmodified lines
5510	MLX5_ACTION_IN_FIELD_METADATA_REG_C_3 = 0x54,	5685	MLX5_ACTION_IN_FIELD_METADATA_REG_C_3 = 0x54,
5511	MLX5_ACTION_IN_FIELD_METADATA_REG_C_4 = 0x55,	5686	MLX5_ACTION_IN_FIELD_METADATA_REG_C_4 = 0x55,
5512	MLX5_ACTION_IN_FIELD_METADATA_REG_C_5 = 0x56,	5687	MLX5_ACTION_IN_FIELD_METADATA_REG_C_5 = 0x56,
		5688	MLX5_ACTION_IN_FIELD_METADATA_REG_C_6 = 0x57,
		5689	MLX5_ACTION_IN_FIELD_METADATA_REG_C_7 = 0x58,
5513	MLX5_ACTION_IN_FIELD_OUT_TCP_SEQ_NUM = 0x59,	5690	MLX5_ACTION_IN_FIELD_OUT_TCP_SEQ_NUM = 0x59,
5514	MLX5_ACTION_IN_FIELD_OUT_TCP_ACK_NUM = 0x5B,	5691	MLX5_ACTION_IN_FIELD_OUT_TCP_ACK_NUM = 0x5B,
5515	};	5692	};
@@ -8406,6 +8583,18 @@ struct mlx5_ifc_pplm_reg_bits { · 2890 unmodified lines
8406	u8 fec_override_admin_50g[0x4];	8583	u8 fec_override_admin_50g[0x4];
8407	u8 fec_override_admin_25g[0x4];	8584	u8 fec_override_admin_25g[0x4];
8408	u8 fec_override_admin_10g_40g[0x4];	8585	u8 fec_override_admin_10g_40g[0x4];
		8586
		8587	u8 fec_override_cap_400g_8x[0x10];
		8588	u8 fec_override_cap_200g_4x[0x10];
		8589
		8590	u8 fec_override_cap_100g_2x[0x10];
		8591	u8 fec_override_cap_50g_1x[0x10];
		8592
		8593	u8 fec_override_admin_400g_8x[0x10];
		8594	u8 fec_override_admin_200g_4x[0x10];
		8595
		8596	u8 fec_override_admin_100g_2x[0x10];
		8597	u8 fec_override_admin_50g_1x[0x10];
8409	};	8598	};
8410		8599
8411	struct mlx5_ifc_ppcnt_reg_bits {	8600	struct mlx5_ifc_ppcnt_reg_bits {
@@ -8732,7 +8921,9 @@ struct mlx5_ifc_mpegc_reg_bits { · 320 unmodified lines
8732	};	8921	};
8733		8922
8734	struct mlx5_ifc_pcam_enhanced_features_bits {	8923	struct mlx5_ifc_pcam_enhanced_features_bits {
8735	u8 reserved_at_0[0x6d];	8924	u8 reserved_at_0[0x68];
		8925	u8 fec_50G_per_lane_in_pplm[0x1];
		8926	u8 reserved_at_69[0x4];
8736	u8 rx_icrc_encapsulated_counter[0x1];	8927	u8 rx_icrc_encapsulated_counter[0x1];
8737	u8 reserved_at_6e[0x4];	8928	u8 reserved_at_6e[0x4];
8738	u8 ptys_extended_ethernet[0x1];	8929	u8 ptys_extended_ethernet[0x1];
@@ -8817,6 +9008,28 @@ struct mlx5_ifc_mcam_access_reg_bits { · 78 unmodified lines
8817	u8 regs_31_to_0[0x20];	9008	u8 regs_31_to_0[0x20];
8818	};	9009	};
8819		9010
		9011	struct mlx5_ifc_mcam_access_reg_bits1 {
		9012	u8 regs_127_to_96[0x20];
		9013
		9014	u8 regs_95_to_64[0x20];
		9015
		9016	u8 regs_63_to_32[0x20];
		9017
		9018	u8 regs_31_to_0[0x20];
		9019	};
		9020
		9021	struct mlx5_ifc_mcam_access_reg_bits2 {
		9022	u8 regs_127_to_99[0x1d];
		9023	u8 mirc[0x1];
		9024	u8 regs_97_to_96[0x2];
		9025
		9026	u8 regs_95_to_64[0x20];
		9027
		9028	u8 regs_63_to_32[0x20];
		9029
		9030	u8 regs_31_to_0[0x20];
		9031	};
		9032
8820	struct mlx5_ifc_mcam_reg_bits {	9033	struct mlx5_ifc_mcam_reg_bits {
8821	u8 reserved_at_0[0x8];	9034	u8 reserved_at_0[0x8];
8822	u8 feature_group[0x8];	9035	u8 feature_group[0x8];
@@ -8827,6 +9040,8 @@ struct mlx5_ifc_mcam_reg_bits { · 4 unmodified lines
8827		9040
8828	union {	9041	union {
8829	struct mlx5_ifc_mcam_access_reg_bits access_regs;	9042	struct mlx5_ifc_mcam_access_reg_bits access_regs;
		9043	struct mlx5_ifc_mcam_access_reg_bits1 access_regs1;
		9044	struct mlx5_ifc_mcam_access_reg_bits2 access_regs2;
8830	u8 reserved_at_0[0x80];	9045	u8 reserved_at_0[0x80];
8831	} mng_access_reg_cap_mask;	9046	} mng_access_reg_cap_mask;
8832		9047
@@ -9432,6 +9647,13 @@ struct mlx5_ifc_mcda_reg_bits { · 599 unmodified lines
9432	u8 data[0][0x20];	9647	u8 data[0][0x20];
9433	};	9648	};
9434		9649
		9650	struct mlx5_ifc_mirc_reg_bits {
		9651	u8 reserved_at_0[0x18];
		9652	u8 status_code[0x8];
		9653
		9654	u8 reserved_at_20[0x20];
		9655	};
		9656
9435	union mlx5_ifc_ports_control_registers_document_bits {	9657	union mlx5_ifc_ports_control_registers_document_bits {
9436	struct mlx5_ifc_bufferx_reg_bits bufferx_reg;	9658	struct mlx5_ifc_bufferx_reg_bits bufferx_reg;
9437	struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits eth_2819_cntrs_grp_data_layout;	9659	struct mlx5_ifc_eth_2819_cntrs_grp_data_layout_bits eth_2819_cntrs_grp_data_layout;
@@ -9487,6 +9709,7 @@ union mlx5_ifc_ports_control_registers_document_bits { · 49 unmodified lines
9487	struct mlx5_ifc_mcqi_reg_bits mcqi_reg;	9709	struct mlx5_ifc_mcqi_reg_bits mcqi_reg;
9488	struct mlx5_ifc_mcc_reg_bits mcc_reg;	9710	struct mlx5_ifc_mcc_reg_bits mcc_reg;
9489	struct mlx5_ifc_mcda_reg_bits mcda_reg;	9711	struct mlx5_ifc_mcda_reg_bits mcda_reg;
		9712	struct mlx5_ifc_mirc_reg_bits mirc_reg;
9490	u8 reserved_at_0[0x60e0];	9713	u8 reserved_at_0[0x60e0];
9491	};	9714	};
9492		9715

include/linux/mmc/sdio_ids.h+2−0

 #define SDIO_DEVICE_ID_BROADCOM_43455		0xa9bf
 #define SDIO_DEVICE_ID_BROADCOM_4354		0x4354
 #define SDIO_DEVICE_ID_BROADCOM_4356		0x4356
+#define SDIO_DEVICE_ID_BROADCOM_4359		0x4359
 #define SDIO_DEVICE_ID_CYPRESS_4373		0x4373
 #define SDIO_DEVICE_ID_CYPRESS_43012		43012
+#define SDIO_DEVICE_ID_CYPRESS_89359		0x4355
 #define SDIO_VENDOR_ID_INTEL			0x0089
 #define SDIO_DEVICE_ID_INTEL_IWMC3200WIMAX	0x1402

include/linux/net.h+1−0

@@ -171,6 +171,7 @@ struct proto_ops { · 170 unmodified lines
171	int (compat_getsockopt)(struct socket sock, int level,	171	int (compat_getsockopt)(struct socket sock, int level,
172	int optname, char __user optval, int __user optlen);	172	int optname, char __user optval, int __user optlen);
173	#endif	173	#endif
		174	void (show_fdinfo)(struct seq_file m, struct socket *sock);
174	int (sendmsg) (struct socket sock, struct msghdr *m,	175	int (sendmsg) (struct socket sock, struct msghdr *m,
175	size_t total_len);	176	size_t total_len);
176	/* Notes for implementing recvmsg:	177	/* Notes for implementing recvmsg:

include/linux/netdev_features.h+8−1

 	NETIF_F_GSO_ESP_BIT,		/* ... ESP with TSO */
 	NETIF_F_GSO_UDP_BIT,		/* ... UFO, deprecated except tuntap */
 	NETIF_F_GSO_UDP_L4_BIT,		/* ... UDP payload GSO (not UFO) */
+	NETIF_F_GSO_FRAGLIST_BIT,		/* ... Fraglist GSO */
 	/**/NETIF_F_GSO_LAST =		/* last bit, see GSO_MASK */
-		NETIF_F_GSO_UDP_L4_BIT,
+		NETIF_F_GSO_FRAGLIST_BIT,
 	NETIF_F_FCOE_CRC_BIT,		/* FCoE CRC32 */
 	NETIF_F_SCTP_CRC_BIT,		/* SCTP checksum offload */
 	NETIF_F_GRO_HW_BIT,		/* Hardware Generic receive offload */
 	NETIF_F_HW_TLS_RECORD_BIT,	/* Offload TLS record */
+	NETIF_F_GRO_FRAGLIST_BIT,	/* Fraglist GRO */
 	/*
 	 * Add your fresh new feature above and remember to update
 #define NETIF_F_GSO_UDP_L4	__NETIF_F(GSO_UDP_L4)
 #define NETIF_F_HW_TLS_TX	__NETIF_F(HW_TLS_TX)
 #define NETIF_F_HW_TLS_RX	__NETIF_F(HW_TLS_RX)
+#define NETIF_F_GRO_FRAGLIST	__NETIF_F(GRO_FRAGLIST)
+#define NETIF_F_GSO_FRAGLIST	__NETIF_F(GSO_FRAGLIST)
 /* Finds the next feature with the highest number of the range of start till 0.
  */
 /* changeable features with no special hardware requirements */
 #define NETIF_F_SOFT_FEATURES	(NETIF_F_GSO | NETIF_F_GRO)
+/* Changeable features with no special hardware requirements that defaults to off. */
+#define NETIF_F_SOFT_FEATURES_OFF	NETIF_F_GRO_FRAGLIST
 #define NETIF_F_VLAN_FEATURES	(NETIF_F_HW_VLAN_CTAG_FILTER | \
 				 NETIF_F_HW_VLAN_CTAG_RX | \
 				 NETIF_F_HW_VLAN_CTAG_TX | \

include/linux/netdevice.h+88−26

@@ -849,6 +849,8 @@ enum tc_setup_type { · 848 unmodified lines
849	TC_SETUP_QDISC_GRED,	849	TC_SETUP_QDISC_GRED,
850	TC_SETUP_QDISC_TAPRIO,	850	TC_SETUP_QDISC_TAPRIO,
851	TC_SETUP_FT,	851	TC_SETUP_FT,
		852	TC_SETUP_QDISC_ETS,
		853	TC_SETUP_QDISC_TBF,
852	};	854	};
853		855
854	/* These structures hold the attributes of bpf state that are being passed	856	/* These structures hold the attributes of bpf state that are being passed
@@ -875,6 +877,7 @@ enum bpf_netdev_command { · 20 unmodified lines
875	struct bpf_prog_offload_ops;	877	struct bpf_prog_offload_ops;
876	struct netlink_ext_ack;	878	struct netlink_ext_ack;
877	struct xdp_umem;	879	struct xdp_umem;
		880	struct xdp_dev_bulk_queue;
878		881
879	struct netdev_bpf {	882	struct netdev_bpf {
880	enum bpf_netdev_command command;	883	enum bpf_netdev_command command;
@@ -936,6 +939,11 @@ struct netdev_name_node { · 55 unmodified lines
936	int netdev_name_node_alt_create(struct net_device dev, const char name);	939	int netdev_name_node_alt_create(struct net_device dev, const char name);
937	int netdev_name_node_alt_destroy(struct net_device dev, const char name);	940	int netdev_name_node_alt_destroy(struct net_device dev, const char name);
938		941
		942	struct netdev_net_notifier {
		943	struct list_head list;
		944	struct notifier_block *nb;
		945	};
		946
939	/*	947	/*
940	* This structure defines the management hooks for network devices.	948	* This structure defines the management hooks for network devices.
941	* The following hooks can be defined; unless noted otherwise, they are	949	* The following hooks can be defined; unless noted otherwise, they are
@@ -1014,7 +1022,7 @@ int netdev_name_node_alt_destroy(struct net_device dev, const char name); · 72 unmodified lines
1014	* Called when a user wants to change the Maximum Transfer Unit	1022	* Called when a user wants to change the Maximum Transfer Unit
1015	* of a device.	1023	* of a device.
1016	*	1024	*
1017	* void (ndo_tx_timeout)(struct net_device dev);	1025	* void (ndo_tx_timeout)(struct net_device dev, unsigned int txqueue);
1018	* Callback used when the transmitter has not made any progress	1026	* Callback used when the transmitter has not made any progress
1019	* for dev->watchdog ticks.	1027	* for dev->watchdog ticks.
1020	*	1028	*
@@ -1281,7 +1289,8 @@ struct net_device_ops { · 260 unmodified lines
1281	int new_mtu);	1289	int new_mtu);
1282	int (ndo_neigh_setup)(struct net_device dev,	1290	int (ndo_neigh_setup)(struct net_device dev,
1283	struct neigh_parms *);	1291	struct neigh_parms *);
1284	void (ndo_tx_timeout) (struct net_device dev);	1292	void (ndo_tx_timeout) (struct net_device dev,
		1293	unsigned int txqueue);
1285		1294
1286	void (ndo_get_stats64)(struct net_device dev,	1295	void (ndo_get_stats64)(struct net_device dev,
1287	struct rtnl_link_stats64 *storage);	1296	struct rtnl_link_stats64 *storage);
@@ -1707,6 +1716,7 @@ enum netdev_priv_flags { · 419 unmodified lines
1707	* @miniq_ingress: ingress/clsact qdisc specific data for	1716	* @miniq_ingress: ingress/clsact qdisc specific data for
1708	* ingress processing	1717	* ingress processing
1709	* @ingress_queue: XXX: need comments on this one	1718	* @ingress_queue: XXX: need comments on this one
		1719	* @nf_hooks_ingress: netfilter hooks executed for ingress packets
1710	* @broadcast: hw bcast address	1720	* @broadcast: hw bcast address
1711	*	1721	*
1712	* @rx_cpu_rmap: CPU reverse-mapping for RX completion interrupts,	1722	* @rx_cpu_rmap: CPU reverse-mapping for RX completion interrupts,
@@ -1788,6 +1798,10 @@ enum netdev_priv_flags { · 75 unmodified lines
1788	*	1798	*
1789	* @wol_enabled: Wake-on-LAN is enabled	1799	* @wol_enabled: Wake-on-LAN is enabled
1790	*	1800	*
		1801	* @net_notifier_list: List of per-net netdev notifier block
		1802	* that follow this device when it is moved
		1803	* to another network namespace.
		1804	*
1791	* FIXME: cleanup struct net_device such that network protocol info	1805	* FIXME: cleanup struct net_device such that network protocol info
1792	* moves out.	1806	* moves out.
1793	*/	1807	*/
@@ -1983,12 +1997,10 @@ struct net_device { · 189 unmodified lines
1983	unsigned int num_tx_queues;	1997	unsigned int num_tx_queues;
1984	unsigned int real_num_tx_queues;	1998	unsigned int real_num_tx_queues;
1985	struct Qdisc *qdisc;	1999	struct Qdisc *qdisc;
1986	#ifdef CONFIG_NET_SCHED
1987	DECLARE_HASHTABLE (qdisc_hash, 4);
1988	#endif
1989	unsigned int tx_queue_len;	2000	unsigned int tx_queue_len;
1990	spinlock_t tx_global_lock;	2001	spinlock_t tx_global_lock;
1991	int watchdog_timeo;	2002
		2003	struct xdp_dev_bulk_queue __percpu *xdp_bulkq;
1992		2004
1993	#ifdef CONFIG_XPS	2005	#ifdef CONFIG_XPS
1994	struct xps_dev_maps __rcu *xps_cpus_map;	2006	struct xps_dev_maps __rcu *xps_cpus_map;
@@ -1998,11 +2010,15 @@ struct net_device { · 3 unmodified lines
1998	struct mini_Qdisc __rcu *miniq_egress;	2010	struct mini_Qdisc __rcu *miniq_egress;
1999	#endif	2011	#endif
2000		2012
		2013	#ifdef CONFIG_NET_SCHED
		2014	DECLARE_HASHTABLE (qdisc_hash, 4);
		2015	#endif
2001	/* These may be needed for future network-power-down code. */	2016	/* These may be needed for future network-power-down code. */
2002	struct timer_list watchdog_timer;	2017	struct timer_list watchdog_timer;
		2018	int watchdog_timeo;
2003		2019
2004	int __percpu *pcpu_refcnt;
2005	struct list_head todo_list;	2020	struct list_head todo_list;
		2021	int __percpu *pcpu_refcnt;
2006		2022
2007	struct list_head link_watch_list;	2023	struct list_head link_watch_list;
2008		2024
@@ -2078,6 +2094,8 @@ struct net_device { · 69 unmodified lines
2078	struct lock_class_key addr_list_lock_key;	2094	struct lock_class_key addr_list_lock_key;
2079	bool proto_down;	2095	bool proto_down;
2080	unsigned wol_enabled:1;	2096	unsigned wol_enabled:1;
		2097
		2098	struct list_head net_notifier_list;
2081	};	2099	};
2082	#define to_net_dev(d) container_of(d, struct net_device, dev)	2100	#define to_net_dev(d) container_of(d, struct net_device, dev)
2083		2101
@@ -2319,7 +2337,8 @@ struct napi_gro_cb { · 235 unmodified lines
2319	/* Number of gro_receive callbacks this packet already went through */	2337	/* Number of gro_receive callbacks this packet already went through */
2320	u8 recursion_counter:4;	2338	u8 recursion_counter:4;
2321		2339
2322	/* 1 bit hole */	2340	/* GRO is done by frag_list pointer chaining. */
		2341	u8 is_flist:1;
2323		2342
2324	/* used to support CHECKSUM_COMPLETE for tunneling protocols */	2343	/* used to support CHECKSUM_COMPLETE for tunneling protocols */
2325	__wsum csum;	2344	__wsum csum;
@@ -2521,6 +2540,12 @@ int unregister_netdevice_notifier(struct notifier_block *nb); · 195 unmodified lines
2521	int register_netdevice_notifier_net(struct net net, struct notifier_block nb);	2540	int register_netdevice_notifier_net(struct net net, struct notifier_block nb);
2522	int unregister_netdevice_notifier_net(struct net *net,	2541	int unregister_netdevice_notifier_net(struct net *net,
2523	struct notifier_block *nb);	2542	struct notifier_block *nb);
		2543	int register_netdevice_notifier_dev_net(struct net_device *dev,
		2544	struct notifier_block *nb,
		2545	struct netdev_net_notifier *nn);
		2546	int unregister_netdevice_notifier_dev_net(struct net_device *dev,
		2547	struct notifier_block *nb,
		2548	struct netdev_net_notifier *nn);
2524		2549
2525	struct netdev_notifier_info {	2550	struct netdev_notifier_info {
2526	struct net_device *dev;	2551	struct net_device *dev;
@@ -2687,6 +2712,7 @@ struct net_device *dev_get_by_napi_id(unsigned int napi_id); · 160 unmodified lines
2687	int netdev_get_name(struct net net, char name, int ifindex);	2712	int netdev_get_name(struct net net, char name, int ifindex);
2688	int dev_restart(struct net_device *dev);	2713	int dev_restart(struct net_device *dev);
2689	int skb_gro_receive(struct sk_buff p, struct sk_buff skb);	2714	int skb_gro_receive(struct sk_buff p, struct sk_buff skb);
		2715	int skb_gro_receive_list(struct sk_buff p, struct sk_buff skb);
2690		2716
2691	static inline unsigned int skb_gro_offset(const struct sk_buff *skb)	2717	static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
2692	{	2718	{
@@ -2823,16 +2849,16 @@ static inline bool __skb_gro_checksum_convert_check(struct sk_buff *skb) · 130 unmodified lines
2823	}	2849	}
2824		2850
2825	static inline void __skb_gro_checksum_convert(struct sk_buff *skb,	2851	static inline void __skb_gro_checksum_convert(struct sk_buff *skb,
2826	__sum16 check, __wsum pseudo)	2852	__wsum pseudo)
2827	{	2853	{
2828	NAPI_GRO_CB(skb)->csum = ~pseudo;	2854	NAPI_GRO_CB(skb)->csum = ~pseudo;
2829	NAPI_GRO_CB(skb)->csum_valid = 1;	2855	NAPI_GRO_CB(skb)->csum_valid = 1;
2830	}	2856	}
2831		2857
2832	#define skb_gro_checksum_try_convert(skb, proto, check, compute_pseudo) \	2858	#define skb_gro_checksum_try_convert(skb, proto, compute_pseudo) \
2833	do { \	2859	do { \
2834	if (__skb_gro_checksum_convert_check(skb)) \	2860	if (__skb_gro_checksum_convert_check(skb)) \
2835	__skb_gro_checksum_convert(skb, check, \	2861	__skb_gro_checksum_convert(skb, \
2836	compute_pseudo(skb, proto)); \	2862	compute_pseudo(skb, proto)); \
2837	} while (0)	2863	} while (0)
2838		2864
@@ -3887,22 +3913,48 @@ void netif_device_attach(struct net_device *dev); · 1048 unmodified lines
3887	*/	3913	*/
3888		3914
3889	enum {	3915	enum {
3890	NETIF_MSG_DRV = 0x0001,	3916	NETIF_MSG_DRV_BIT,
3891	NETIF_MSG_PROBE = 0x0002,	3917	NETIF_MSG_PROBE_BIT,
3892	NETIF_MSG_LINK = 0x0004,	3918	NETIF_MSG_LINK_BIT,
3893	NETIF_MSG_TIMER = 0x0008,	3919	NETIF_MSG_TIMER_BIT,
3894	NETIF_MSG_IFDOWN = 0x0010,	3920	NETIF_MSG_IFDOWN_BIT,
3895	NETIF_MSG_IFUP = 0x0020,	3921	NETIF_MSG_IFUP_BIT,
3896	NETIF_MSG_RX_ERR = 0x0040,	3922	NETIF_MSG_RX_ERR_BIT,
3897	NETIF_MSG_TX_ERR = 0x0080,	3923	NETIF_MSG_TX_ERR_BIT,
3898	NETIF_MSG_TX_QUEUED = 0x0100,	3924	NETIF_MSG_TX_QUEUED_BIT,
3899	NETIF_MSG_INTR = 0x0200,	3925	NETIF_MSG_INTR_BIT,
3900	NETIF_MSG_TX_DONE = 0x0400,	3926	NETIF_MSG_TX_DONE_BIT,
3901	NETIF_MSG_RX_STATUS = 0x0800,	3927	NETIF_MSG_RX_STATUS_BIT,
3902	NETIF_MSG_PKTDATA = 0x1000,	3928	NETIF_MSG_PKTDATA_BIT,
3903	NETIF_MSG_HW = 0x2000,	3929	NETIF_MSG_HW_BIT,
3904	NETIF_MSG_WOL = 0x4000,	3930	NETIF_MSG_WOL_BIT,
		3931
		3932	/* When you add a new bit above, update netif_msg_class_names array
		3933	* in net/ethtool/common.c
		3934	*/
		3935	NETIF_MSG_CLASS_COUNT,
3905	};	3936	};
		3937	/* Both ethtool_ops interface and internal driver implementation use u32 */
		3938	static_assert(NETIF_MSG_CLASS_COUNT <= 32);
		3939
		3940	#define __NETIF_MSG_BIT(bit) ((u32)1 << (bit))
		3941	#define __NETIF_MSG(name) __NETIF_MSG_BIT(NETIF_MSG_ ## name ## _BIT)
		3942
		3943	#define NETIF_MSG_DRV __NETIF_MSG(DRV)
		3944	#define NETIF_MSG_PROBE __NETIF_MSG(PROBE)
		3945	#define NETIF_MSG_LINK __NETIF_MSG(LINK)
		3946	#define NETIF_MSG_TIMER __NETIF_MSG(TIMER)
		3947	#define NETIF_MSG_IFDOWN __NETIF_MSG(IFDOWN)
		3948	#define NETIF_MSG_IFUP __NETIF_MSG(IFUP)
		3949	#define NETIF_MSG_RX_ERR __NETIF_MSG(RX_ERR)
		3950	#define NETIF_MSG_TX_ERR __NETIF_MSG(TX_ERR)
		3951	#define NETIF_MSG_TX_QUEUED __NETIF_MSG(TX_QUEUED)
		3952	#define NETIF_MSG_INTR __NETIF_MSG(INTR)
		3953	#define NETIF_MSG_TX_DONE __NETIF_MSG(TX_DONE)
		3954	#define NETIF_MSG_RX_STATUS __NETIF_MSG(RX_STATUS)
		3955	#define NETIF_MSG_PKTDATA __NETIF_MSG(PKTDATA)
		3956	#define NETIF_MSG_HW __NETIF_MSG(HW)
		3957	#define NETIF_MSG_WOL __NETIF_MSG(WOL)
3906		3958
3907	#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)	3959	#define netif_msg_drv(p) ((p)->msg_enable & NETIF_MSG_DRV)
3908	#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)	3960	#define netif_msg_probe(p) ((p)->msg_enable & NETIF_MSG_PROBE)
@@ -4393,6 +4445,15 @@ struct netdev_notifier_bonding_info { · 484 unmodified lines
4393	void netdev_bonding_info_change(struct net_device *dev,	4445	void netdev_bonding_info_change(struct net_device *dev,
4394	struct netdev_bonding_info *bonding_info);	4446	struct netdev_bonding_info *bonding_info);
4395		4447
		4448	#if IS_ENABLED(CONFIG_ETHTOOL_NETLINK)
		4449	void ethtool_notify(struct net_device dev, unsigned int cmd, const void data);
		4450	#else
		4451	static inline void ethtool_notify(struct net_device *dev, unsigned int cmd,
		4452	const void *data)
		4453	{
		4454	}
		4455	#endif
		4456
4396	static inline	4457	static inline
4397	struct sk_buff skb_gso_segment(struct sk_buff skb, netdev_features_t features)	4458	struct sk_buff skb_gso_segment(struct sk_buff skb, netdev_features_t features)
4398	{	4459	{
@@ -4554,6 +4615,7 @@ static inline bool net_gso_ok(netdev_features_t features, int gso_type) · 155 unmodified lines
4554	BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT));	4615	BUILD_BUG_ON(SKB_GSO_ESP != (NETIF_F_GSO_ESP >> NETIF_F_GSO_SHIFT));
4555	BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_GSO_UDP >> NETIF_F_GSO_SHIFT));	4616	BUILD_BUG_ON(SKB_GSO_UDP != (NETIF_F_GSO_UDP >> NETIF_F_GSO_SHIFT));
4556	BUILD_BUG_ON(SKB_GSO_UDP_L4 != (NETIF_F_GSO_UDP_L4 >> NETIF_F_GSO_SHIFT));	4617	BUILD_BUG_ON(SKB_GSO_UDP_L4 != (NETIF_F_GSO_UDP_L4 >> NETIF_F_GSO_SHIFT));
		4618	BUILD_BUG_ON(SKB_GSO_FRAGLIST != (NETIF_F_GSO_FRAGLIST >> NETIF_F_GSO_SHIFT));
4557		4619
4558	return (features & feature) == feature;	4620	return (features & feature) == feature;
4559	}	4621	}

include/linux/phy.h+96−27

 #include <linux/linkmode.h>
 #include <linux/mdio.h>
 #include <linux/mii.h>
+#include <linux/mii_timestamper.h>
 #include <linux/module.h>
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/mod_devicetable.h>
+#include <linux/u64_stats_sync.h>
 #include <linux/atomic.h>
 	PHY_INTERFACE_MODE_2500BASEX,
 	PHY_INTERFACE_MODE_RXAUI,
 	PHY_INTERFACE_MODE_XAUI,
-	/* 10GBASE-KR, XFI, SFI - single lane 10G Serdes */
+	/* 10GBASE-R, XFI, SFI - single lane 10G Serdes */
-	PHY_INTERFACE_MODE_10GKR,
+	PHY_INTERFACE_MODE_10GBASER,
 	PHY_INTERFACE_MODE_USXGMII,
+	/* 10GBASE-KR - with Clause 73 AN */
+	PHY_INTERFACE_MODE_10GKR,
 	PHY_INTERFACE_MODE_MAX,
 } phy_interface_t;
 		return "rxaui";
 	case PHY_INTERFACE_MODE_XAUI:
 		return "xaui";
-	case PHY_INTERFACE_MODE_10GKR:
+	case PHY_INTERFACE_MODE_10GBASER:
-		return "10gbase-kr";
+		return "10gbase-r";
 	case PHY_INTERFACE_MODE_USXGMII:
 		return "usxgmii";
+	case PHY_INTERFACE_MODE_10GKR:
+		return "10gbase-kr";
 	default:
 		return "unknown";
 	}
 struct sfp_upstream_ops;
 struct sk_buff;
+struct mdio_bus_stats {
+	u64_stats_t transfers;
+	u64_stats_t errors;
+	u64_stats_t writes;
+	u64_stats_t reads;
+	/* Must be last, add new statistics above */
+	struct u64_stats_sync syncp;
+};
 /*
  * The Bus class for PHYs.  Devices which provide access to
  * PHYs should register using this structure
 	int (*read)(struct mii_bus *bus, int addr, int regnum);
 	int (*write)(struct mii_bus *bus, int addr, int regnum, u16 val);
 	int (*reset)(struct mii_bus *bus);
+	struct mdio_bus_stats stats[PHY_MAX_ADDR];
 	/*
 	 * A lock to ensure that only one thing can read/write
 	u32 device_ids[8];
 };
+struct macsec_context;
+struct macsec_ops;
 /* phy_device: An instance of a PHY
  *
  * drv: Pointer to the driver for this PHY instance
  * attached_dev: The attached enet driver's device instance ptr
  * adjust_link: Callback for the enet controller to respond to
  * changes in the link state.
+ * macsec_ops: MACsec offloading ops.
  *
  * speed, duplex, pause, supported, advertising, lp_advertising,
  * and autoneg are used like in mii_if_info
 	struct sfp_bus *sfp_bus;
 	struct phylink *phylink;
 	struct net_device *attached_dev;
+	struct mii_timestamper *mii_ts;
 	u8 mdix;
 	u8 mdix_ctrl;
 	void (*phy_link_change)(struct phy_device *, bool up, bool do_carrier);
 	void (*adjust_link)(struct net_device *dev);
+#if IS_ENABLED(CONFIG_MACSEC)
+	/* MACsec management functions */
+	const struct macsec_ops *macsec_ops;
+#endif
 };
 #define to_phy_device(d) container_of(to_mdio_device(d), \
 				      struct phy_device, mdio)
 	 */
 	int (*match_phy_device)(struct phy_device *phydev);
-	/* Handles ethtool queries for hardware time stamping. */
-	int (*ts_info)(struct phy_device *phydev, struct ethtool_ts_info *ti);
-	/* Handles SIOCSHWTSTAMP ioctl for hardware time stamping. */
-	int  (*hwtstamp)(struct phy_device *phydev, struct ifreq *ifr);
-	/*
-	 * Requests a Rx timestamp for 'skb'. If the skb is accepted,
-	 * the phy driver promises to deliver it using netif_rx() as
-	 * soon as a timestamp becomes available. One of the
-	 * PTP_CLASS_ values is passed in 'type'. The function must
-	 * return true if the skb is accepted for delivery.
-	 */
-	bool (*rxtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
-	/*
-	 * Requests a Tx timestamp for 'skb'. The phy driver promises
-	 * to deliver it using skb_complete_tx_timestamp() as soon as a
-	 * timestamp becomes available. One of the PTP_CLASS_ values
-	 * is passed in 'type'.
-	 */
-	void (*txtstamp)(struct phy_device *dev, struct sk_buff *skb, int type);
 	/* Some devices (e.g. qnap TS-119P II) require PHY register changes to
 	 * enable Wake on LAN, so set_wol is provided to be called in the
 	 * ethernet driver's set_wol function. */
 	return phydev->irq == PHY_POLL;
 }
+/**
+ * phy_has_hwtstamp - Tests whether a PHY time stamp configuration.
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_has_hwtstamp(struct phy_device *phydev)
+{
+	return phydev && phydev->mii_ts && phydev->mii_ts->hwtstamp;
+}
+/**
+ * phy_has_rxtstamp - Tests whether a PHY supports receive time stamping.
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_has_rxtstamp(struct phy_device *phydev)
+{
+	return phydev && phydev->mii_ts && phydev->mii_ts->rxtstamp;
+}
+/**
+ * phy_has_tsinfo - Tests whether a PHY reports time stamping and/or
+ * PTP hardware clock capabilities.
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_has_tsinfo(struct phy_device *phydev)
+{
+	return phydev && phydev->mii_ts && phydev->mii_ts->ts_info;
+}
+/**
+ * phy_has_txtstamp - Tests whether a PHY supports transmit time stamping.
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_has_txtstamp(struct phy_device *phydev)
+{
+	return phydev && phydev->mii_ts && phydev->mii_ts->txtstamp;
+}
+static inline int phy_hwtstamp(struct phy_device *phydev, struct ifreq *ifr)
+{
+	return phydev->mii_ts->hwtstamp(phydev->mii_ts, ifr);
+}
+static inline bool phy_rxtstamp(struct phy_device *phydev, struct sk_buff *skb,
+				int type)
+{
+	return phydev->mii_ts->rxtstamp(phydev->mii_ts, skb, type);
+}
+static inline int phy_ts_info(struct phy_device *phydev,
+			      struct ethtool_ts_info *tsinfo)
+{
+	return phydev->mii_ts->ts_info(phydev->mii_ts, tsinfo);
+}
+static inline void phy_txtstamp(struct phy_device *phydev, struct sk_buff *skb,
+				int type)
+{
+	phydev->mii_ts->txtstamp(phydev->mii_ts, skb, type);
+}
 /**
  * phy_is_internal - Convenience function for testing if a PHY is internal
  * @phydev: the phy_device struct
 void phy_attached_print(struct phy_device *phydev, const char *fmt, ...)
 	__printf(2, 3);
+char *phy_attached_info_irq(struct phy_device *phydev)
+	__malloc;
 void phy_attached_info(struct phy_device *phydev);
 /* Clause 22 PHY */
 int genphy_read_abilities(struct phy_device *phydev);
 int genphy_setup_forced(struct phy_device *phydev);
 int genphy_restart_aneg(struct phy_device *phydev);
+int genphy_check_and_restart_aneg(struct phy_device *phydev, bool restart);
 int genphy_config_eee_advert(struct phy_device *phydev);
 int __genphy_config_aneg(struct phy_device *phydev, bool changed);
 int genphy_aneg_done(struct phy_device *phydev);
 int genphy_update_link(struct phy_device *phydev);
 int genphy_read_lpa(struct phy_device *phydev);
+int genphy_read_status_fixed(struct phy_device *phydev);
 int genphy_read_status(struct phy_device *phydev);
 int genphy_suspend(struct phy_device *phydev);
 int genphy_resume(struct phy_device *phydev);
 int phy_ethtool_ksettings_set(struct phy_device *phydev,
 			      const struct ethtool_link_ksettings *cmd);
 int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd);
+int phy_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd);
+int phy_do_ioctl_running(struct net_device *dev, struct ifreq *ifr, int cmd);
 void phy_request_interrupt(struct phy_device *phydev);
 void phy_free_interrupt(struct phy_device *phydev);
 void phy_print_status(struct phy_device *phydev);

include/linux/phylink.h+2−0

  * struct phylink_config - PHYLINK configuration structure
  * @dev: a pointer to a struct device associated with the MAC
  * @type: operation type of PHYLINK instance
+ * @pcs_poll: MAC PCS cannot provide link change interrupt
  */
 struct phylink_config {
 	struct device *dev;
 	enum phylink_op_type type;
+	bool pcs_poll;
 };
 /**

include/linux/platform_data/eth_ixp4xx.h+19−0

@@ -0,0 +1,19 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __PLATFORM_DATA_ETH_IXP4XX
	3	#define __PLATFORM_DATA_ETH_IXP4XX
	4
	5	#include <linux/types.h>
	6
	7	#define IXP4XX_ETH_NPEA 0x00
	8	#define IXP4XX_ETH_NPEB 0x10
	9	#define IXP4XX_ETH_NPEC 0x20
	10
	11	/* Information about built-in Ethernet MAC interfaces */
	12	struct eth_plat_info {
	13	u8 phy; /* MII PHY ID, 0 - 31 */
	14	u8 rxq; /* configurable, currently 0 - 31 only */
	15	u8 txreadyq;
	16	u8 hwaddr[6];
	17	};
	18
	19	#endif

include/linux/platform_data/wan_ixp4xx_hss.h+17−0

@@ -0,0 +1,17 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef __PLATFORM_DATA_WAN_IXP4XX_HSS_H
	3	#define __PLATFORM_DATA_WAN_IXP4XX_HSS_H
	4
	5	#include <linux/types.h>
	6
	7	/* Information about built-in HSS (synchronous serial) interfaces */
	8	struct hss_plat_info {
	9	int (*set_clock)(int port, unsigned int clock_type);
	10	int (open)(int port, void pdev,
	11	void (set_carrier_cb)(void pdev, int carrier));
	12	void (close)(int port, void pdev);
	13	u8 txreadyq;
	14	u32 timer_freq;
	15	};
	16
	17	#endif

include/linux/ptp_clock_kernel.h+9−0

 int ptp_schedule_worker(struct ptp_clock *ptp, unsigned long delay);
+/**
+ * ptp_cancel_worker_sync() - cancel ptp auxiliary clock
+ *
+ * @ptp:     The clock obtained from ptp_clock_register().
+ */
+void ptp_cancel_worker_sync(struct ptp_clock *ptp);
 #else
 static inline struct ptp_clock *ptp_clock_register(struct ptp_clock_info *info,
 						   struct device *parent)
 static inline int ptp_schedule_worker(struct ptp_clock *ptp,
 				      unsigned long delay)
 { return -EOPNOTSUPP; }
+static inline void ptp_cancel_worker_sync(struct ptp_clock *ptp)
+{ }
 #endif

include/linux/ptr_ring.h+1−0

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	#include <linux/types.h>	23	#include <linux/types.h>
24	#include <linux/compiler.h>	24	#include <linux/compiler.h>
25	#include <linux/slab.h>	25	#include <linux/slab.h>
		26	#include <linux/mm.h>
26	#include <asm/errno.h>	27	#include <asm/errno.h>
27	#endif	28	#endif
28		29

include/linux/qed/common_hsi.h+29−15

@@ -76,7 +76,6 @@ · 75 unmodified lines
76		76
77	#define FW_ASSERT_GENERAL_ATTN_IDX 32	77	#define FW_ASSERT_GENERAL_ATTN_IDX 32
78		78
79	#define MAX_PINNED_CCFC 32
80		79
81	/* Queue Zone sizes in bytes */	80	/* Queue Zone sizes in bytes */
82	#define TSTORM_QZONE_SIZE 8	81	#define TSTORM_QZONE_SIZE 8
@@ -105,12 +104,19 @@ · 22 unmodified lines
105		104
106	#define CORE_SPQE_PAGE_SIZE_BYTES 4096	105	#define CORE_SPQE_PAGE_SIZE_BYTES 4096
107		106
108	#define MAX_NUM_LL2_RX_QUEUES 48	107	/* Number of LL2 RAM based queues */
109	#define MAX_NUM_LL2_TX_STATS_COUNTERS 48	108	#define MAX_NUM_LL2_RX_RAM_QUEUES 32
		109
		110	/* Number of LL2 context based queues */
		111	#define MAX_NUM_LL2_RX_CTX_QUEUES 208
		112	#define MAX_NUM_LL2_RX_QUEUES \
		113	(MAX_NUM_LL2_RX_RAM_QUEUES + MAX_NUM_LL2_RX_CTX_QUEUES)
		114
		115	#define MAX_NUM_LL2_TX_STATS_COUNTERS 48
110		116
111	#define FW_MAJOR_VERSION 8	117	#define FW_MAJOR_VERSION 8
112	#define FW_MINOR_VERSION 37	118	#define FW_MINOR_VERSION 42
113	#define FW_REVISION_VERSION 7	119	#define FW_REVISION_VERSION 2
114	#define FW_ENGINEERING_VERSION 0	120	#define FW_ENGINEERING_VERSION 0
115		121
116	/***********************/	122	/***********************/
@@ -132,10 +138,10 @@ · 15 unmodified lines
132	#define MAX_NUM_VFS (MAX_NUM_VFS_K2)	138	#define MAX_NUM_VFS (MAX_NUM_VFS_K2)
133		139
134	#define MAX_NUM_FUNCTIONS_BB (MAX_NUM_PFS_BB + MAX_NUM_VFS_BB)	140	#define MAX_NUM_FUNCTIONS_BB (MAX_NUM_PFS_BB + MAX_NUM_VFS_BB)
135	#define MAX_NUM_FUNCTIONS (MAX_NUM_PFS + MAX_NUM_VFS)
136		141
137	#define MAX_FUNCTION_NUMBER_BB (MAX_NUM_PFS + MAX_NUM_VFS_BB)	142	#define MAX_FUNCTION_NUMBER_BB (MAX_NUM_PFS + MAX_NUM_VFS_BB)
138	#define MAX_FUNCTION_NUMBER (MAX_NUM_PFS + MAX_NUM_VFS)	143	#define MAX_FUNCTION_NUMBER_K2 (MAX_NUM_PFS + MAX_NUM_VFS_K2)
		144	#define MAX_NUM_FUNCTIONS (MAX_FUNCTION_NUMBER_K2)
139		145
140	#define MAX_NUM_VPORTS_K2 (208)	146	#define MAX_NUM_VPORTS_K2 (208)
141	#define MAX_NUM_VPORTS_BB (160)	147	#define MAX_NUM_VPORTS_BB (160)
@@ -222,6 +228,7 @@ · 80 unmodified lines
222	#define DQ_XCM_TOE_TX_BD_PROD_CMD DQ_XCM_AGG_VAL_SEL_WORD4	228	#define DQ_XCM_TOE_TX_BD_PROD_CMD DQ_XCM_AGG_VAL_SEL_WORD4
223	#define DQ_XCM_TOE_MORE_TO_SEND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG3	229	#define DQ_XCM_TOE_MORE_TO_SEND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG3
224	#define DQ_XCM_TOE_LOCAL_ADV_WND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG4	230	#define DQ_XCM_TOE_LOCAL_ADV_WND_SEQ_CMD DQ_XCM_AGG_VAL_SEL_REG4
		231	#define DQ_XCM_ROCE_ACK_EDPM_DORQ_SEQ_CMD DQ_XCM_AGG_VAL_SEL_WORD5
225		232
226	/* UCM agg val selection (HW) */	233	/* UCM agg val selection (HW) */
227	#define DQ_UCM_AGG_VAL_SEL_WORD0 0	234	#define DQ_UCM_AGG_VAL_SEL_WORD0 0
@@ -340,6 +347,10 @@ · 112 unmodified lines
340	#define DQ_PWM_OFFSET_TCM_ROCE_RQ_PROD (DQ_PWM_OFFSET_TCM16_BASE + 1)	347	#define DQ_PWM_OFFSET_TCM_ROCE_RQ_PROD (DQ_PWM_OFFSET_TCM16_BASE + 1)
341	#define DQ_PWM_OFFSET_TCM_IWARP_RQ_PROD (DQ_PWM_OFFSET_TCM16_BASE + 3)	348	#define DQ_PWM_OFFSET_TCM_IWARP_RQ_PROD (DQ_PWM_OFFSET_TCM16_BASE + 3)
342		349
		350	/* DQ_DEMS_AGG_VAL_BASE */
		351	#define DQ_PWM_OFFSET_TCM_LL2_PROD_UPDATE \
		352	(DQ_PWM_OFFSET_TCM32_BASE + DQ_TCM_AGG_VAL_SEL_REG9 - 4)
		353
343	#define DQ_REGION_SHIFT (12)	354	#define DQ_REGION_SHIFT (12)
344		355
345	/* DPM */	356	/* DPM */
@@ -395,6 +406,7 @@ · 49 unmodified lines
395		406
396	/* Number of Protocol Indices per Status Block */	407	/* Number of Protocol Indices per Status Block */
397	#define PIS_PER_SB_E4 12	408	#define PIS_PER_SB_E4 12
		409	#define MAX_PIS_PER_SB PIS_PER_SB
398		410
399	#define CAU_HC_STOPPED_STATE 3	411	#define CAU_HC_STOPPED_STATE 3
400	#define CAU_HC_DISABLE_STATE 4	412	#define CAU_HC_DISABLE_STATE 4
@@ -425,8 +437,6 @@ · 24 unmodified lines
425	#define IGU_MEM_PBA_MSIX_RESERVED_UPPER 0x03ff	437	#define IGU_MEM_PBA_MSIX_RESERVED_UPPER 0x03ff
426		438
427	#define IGU_CMD_INT_ACK_BASE 0x0400	439	#define IGU_CMD_INT_ACK_BASE 0x0400
428	#define IGU_CMD_INT_ACK_UPPER (IGU_CMD_INT_ACK_BASE + \
429	MAX_TOT_SB_PER_PATH - 1)
430	#define IGU_CMD_INT_ACK_RESERVED_UPPER 0x05ff	440	#define IGU_CMD_INT_ACK_RESERVED_UPPER 0x05ff
431		441
432	#define IGU_CMD_ATTN_BIT_UPD_UPPER 0x05f0	442	#define IGU_CMD_ATTN_BIT_UPD_UPPER 0x05f0
@@ -439,8 +449,6 @@ · 6 unmodified lines
439	#define IGU_REG_SISR_MDPC_WOMASK_UPPER 0x05f6	449	#define IGU_REG_SISR_MDPC_WOMASK_UPPER 0x05f6
440		450
441	#define IGU_CMD_PROD_UPD_BASE 0x0600	451	#define IGU_CMD_PROD_UPD_BASE 0x0600
442	#define IGU_CMD_PROD_UPD_UPPER (IGU_CMD_PROD_UPD_BASE +\
443	MAX_TOT_SB_PER_PATH - 1)
444	#define IGU_CMD_PROD_UPD_RESERVED_UPPER 0x07ff	452	#define IGU_CMD_PROD_UPD_RESERVED_UPPER 0x07ff
445		453
446	/*****************/	454	/*****************/
@@ -652,8 +660,8 @@ · 205 unmodified lines
652	#define PBF_MAX_CMD_LINES 3328	660	#define PBF_MAX_CMD_LINES 3328
653		661
654	/* Number of BTB blocks. Each block is 256B. */	662	/* Number of BTB blocks. Each block is 256B. */
655	#define BTB_MAX_BLOCKS 1440	663	#define BTB_MAX_BLOCKS_BB 1440
656		664	#define BTB_MAX_BLOCKS_K2 1840
657	/*****************/	665	/*****************/
658	/* PRS CONSTANTS */	666	/* PRS CONSTANTS */
659	/*****************/	667	/*****************/
@@ -730,6 +738,8 @@ enum protocol_type { · 70 unmodified lines
730	PROTOCOLID_PREROCE,	738	PROTOCOLID_PREROCE,
731	PROTOCOLID_COMMON,	739	PROTOCOLID_COMMON,
732	PROTOCOLID_RESERVED1,	740	PROTOCOLID_RESERVED1,
		741	PROTOCOLID_RDMA,
		742	PROTOCOLID_SCSI,
733	MAX_PROTOCOL_TYPE	743	MAX_PROTOCOL_TYPE
734	};	744	};
735		745
@@ -750,6 +760,10 @@ union rdma_eqe_data { · 14 unmodified lines
750	struct rdma_eqe_destroy_qp rdma_destroy_qp_data;	760	struct rdma_eqe_destroy_qp rdma_destroy_qp_data;
751	};	761	};
752		762
		763	struct tstorm_queue_zone {
		764	__le32 reserved[2];
		765	};
		766
753	/* Ustorm Queue Zone */	767	/* Ustorm Queue Zone */
754	struct ustorm_eth_queue_zone {	768	struct ustorm_eth_queue_zone {
755	struct coalescing_timeset int_coalescing_timeset;	769	struct coalescing_timeset int_coalescing_timeset;
@@ -872,8 +886,8 @@ struct db_l2_dpm_data { · 116 unmodified lines
872	#define DB_L2_DPM_DATA_RESERVED0_SHIFT 27	886	#define DB_L2_DPM_DATA_RESERVED0_SHIFT 27
873	#define DB_L2_DPM_DATA_SGE_NUM_MASK 0x7	887	#define DB_L2_DPM_DATA_SGE_NUM_MASK 0x7
874	#define DB_L2_DPM_DATA_SGE_NUM_SHIFT 28	888	#define DB_L2_DPM_DATA_SGE_NUM_SHIFT 28
875	#define DB_L2_DPM_DATA_GFS_SRC_EN_MASK 0x1	889	#define DB_L2_DPM_DATA_TGFS_SRC_EN_MASK 0x1
876	#define DB_L2_DPM_DATA_GFS_SRC_EN_SHIFT 31	890	#define DB_L2_DPM_DATA_TGFS_SRC_EN_SHIFT 31
877	};	891	};
878		892
879	/* Structure for SGE in a DPM doorbell of type DPM_L2_BD */	893	/* Structure for SGE in a DPM doorbell of type DPM_L2_BD */

include/linux/qed/eth_common.h+56−22

 /********************/
 #define ETH_HSI_VER_MAJOR		3
-#define ETH_HSI_VER_MINOR		10
+#define ETH_HSI_VER_MINOR		11
-#define ETH_HSI_VER_NO_PKT_LEN_TUNN	5
+#define ETH_HSI_VER_NO_PKT_LEN_TUNN         5
+/* Maximum number of pinned L2 connections (CIDs) */
+#define ETH_PINNED_CONN_MAX_NUM             32
 #define ETH_CACHE_LINE_SIZE		64
 #define ETH_RX_CQE_GAP			32
 #define ETH_TX_MIN_BDS_PER_TUNN_IPV6_WITH_EXT_PKT	3
 #define ETH_TX_MIN_BDS_PER_IPV6_WITH_EXT_PKT		2
 #define ETH_TX_MIN_BDS_PER_PKT_W_LOOPBACK_MODE		2
+#define ETH_TX_MIN_BDS_PER_PKT_W_VPORT_FORWARDING	4
 #define ETH_TX_MAX_NON_LSO_PKT_LEN		(9700 - (4 + 4 + 12 + 8))
 #define ETH_TX_MAX_LSO_HDR_BYTES			510
 #define ETH_TX_LSO_WINDOW_BDS_NUM			(18 - 1)
 #define ETH_NUM_STATISTIC_COUNTERS_QUAD_VF_ZONE \
 	(ETH_NUM_STATISTIC_COUNTERS - 3 * MAX_NUM_VFS / 4)
-/* Maximum number of buffers, used for RX packet placement */
 #define ETH_RX_MAX_BUFF_PER_PKT		5
-#define ETH_RX_BD_THRESHOLD		12
+#define ETH_RX_BD_THRESHOLD             16
 /* Num of MAC/VLAN filters */
 #define ETH_NUM_MAC_FILTERS		512
 #define ETH_RSS_ENGINE_NUM_BB		127
 /* TPA constants */
-#define ETH_TPA_MAX_AGGS_NUM		64
+#define ETH_TPA_MAX_AGGS_NUM                64
-#define ETH_TPA_CQE_START_LEN_LIST_SIZE	ETH_RX_MAX_BUFF_PER_PKT
+#define ETH_TPA_CQE_START_BW_LEN_LIST_SIZE  2
-#define ETH_TPA_CQE_CONT_LEN_LIST_SIZE	6
+#define ETH_TPA_CQE_CONT_LEN_LIST_SIZE      6
-#define ETH_TPA_CQE_END_LEN_LIST_SIZE	4
+#define ETH_TPA_CQE_END_LEN_LIST_SIZE       4
 /* Control frame check constants */
-#define ETH_CTL_FRAME_ETH_TYPE_NUM	4
+#define ETH_CTL_FRAME_ETH_TYPE_NUM        4
 /* GFS constants */
 #define ETH_GFT_TRASHCAN_VPORT         0x1FF	/* GFT drop flow vport number */
 /* Destination port mode */
-enum dest_port_mode {
+enum dst_port_mode {
-	DEST_PORT_PHY,
+	DST_PORT_PHY,
-	DEST_PORT_LOOPBACK,
+	DST_PORT_LOOPBACK,
-	DEST_PORT_PHY_LOOPBACK,
+	DST_PORT_PHY_LOOPBACK,
-	DEST_PORT_DROP,
+	DST_PORT_DROP,
-	MAX_DEST_PORT_MODE
+	MAX_DST_PORT_MODE
 };
 /* Ethernet address type */
 #define ETH_TX_DATA_2ND_BD_TUNN_INNER_L2_HDR_SIZE_W_SHIFT	0
 #define ETH_TX_DATA_2ND_BD_TUNN_INNER_ETH_TYPE_MASK		0x3
 #define ETH_TX_DATA_2ND_BD_TUNN_INNER_ETH_TYPE_SHIFT		4
-#define ETH_TX_DATA_2ND_BD_DEST_PORT_MODE_MASK			0x3
+#define ETH_TX_DATA_2ND_BD_DST_PORT_MODE_MASK			0x3
-#define ETH_TX_DATA_2ND_BD_DEST_PORT_MODE_SHIFT			6
+#define ETH_TX_DATA_2ND_BD_DST_PORT_MODE_SHIFT			6
 #define ETH_TX_DATA_2ND_BD_START_BD_MASK			0x1
 #define ETH_TX_DATA_2ND_BD_START_BD_SHIFT			8
 #define ETH_TX_DATA_2ND_BD_TUNN_TYPE_MASK			0x3
 	struct eth_tunnel_parsing_flags tunnel_pars_flags;
 	u8 bd_num;
 	u8 reserved;
-	__le16 flow_id;
+	__le16 reserved2;
-	u8 reserved1[11];
+	__le32 flow_id_or_resource_id;
+	u8 reserved1[7];
 	struct eth_pmd_flow_flags pmd_flags;
 };
 	struct eth_tunnel_parsing_flags tunnel_pars_flags;
 	u8 tpa_agg_index;
 	u8 header_len;
-	__le16 ext_bd_len_list[ETH_TPA_CQE_START_LEN_LIST_SIZE];
+	__le16 bw_ext_bd_len_list[ETH_TPA_CQE_START_BW_LEN_LIST_SIZE];
-	__le16 flow_id;
+	__le16 reserved2;
-	u8 reserved;
+	__le32 flow_id_or_resource_id;
+	u8 reserved[3];
 	struct eth_pmd_flow_flags pmd_flags;
 };
 	struct eth_tx_data_3rd_bd data;
 };
+/* The parsing information data for the forth tx bd of a given packet. */
+struct eth_tx_data_4th_bd {
+	u8 dst_vport_id;
+	u8 reserved4;
+	__le16 bitfields;
+#define ETH_TX_DATA_4TH_BD_DST_VPORT_ID_VALID_MASK  0x1
+#define ETH_TX_DATA_4TH_BD_DST_VPORT_ID_VALID_SHIFT 0
+#define ETH_TX_DATA_4TH_BD_RESERVED1_MASK           0x7F
+#define ETH_TX_DATA_4TH_BD_RESERVED1_SHIFT          1
+#define ETH_TX_DATA_4TH_BD_START_BD_MASK            0x1
+#define ETH_TX_DATA_4TH_BD_START_BD_SHIFT           8
+#define ETH_TX_DATA_4TH_BD_RESERVED2_MASK           0x7F
+#define ETH_TX_DATA_4TH_BD_RESERVED2_SHIFT          9
+	__le16 reserved3;
+};
+/* The forth tx bd of a given packet */
+struct eth_tx_4th_bd {
+	struct regpair addr; /* Single continuous buffer */
+	__le16 nbytes; /* Number of bytes in this BD */
+	struct eth_tx_data_4th_bd data; /* Parsing information data */
+};
 /* Complementary information for the regular tx bd of a given packet */
 struct eth_tx_data_bd {
 	__le16 reserved0;
 	struct eth_tx_1st_bd first_bd;
 	struct eth_tx_2nd_bd second_bd;
 	struct eth_tx_3rd_bd third_bd;
+	struct eth_tx_4th_bd fourth_bd;
 	struct eth_tx_bd reg_bd;
 };
 	MAX_ETH_TX_TUNN_TYPE
 };
+/* Mstorm Queue Zone */
+struct mstorm_eth_queue_zone {
+	struct eth_rx_prod_data rx_producers;
+	__le32 reserved[3];
+};
 /* Ystorm Queue Zone */
 struct xstorm_eth_queue_zone {
 	struct coalescing_timeset int_coalescing_timeset;

include/linux/qed/iscsi_common.h+24−40

 	struct regpair r2tq_pbl_addr;
 	struct regpair xhq_pbl_addr;
 	struct regpair uhq_pbl_addr;
-	__le32 initial_ack;
 	__le16 physical_q0;
 	__le16 physical_q1;
 	u8 flags;
 #define ISCSI_CONN_OFFLOAD_PARAMS_RESTRICTED_MODE_SHIFT	2
 #define ISCSI_CONN_OFFLOAD_PARAMS_RESERVED1_MASK	0x1F
 #define ISCSI_CONN_OFFLOAD_PARAMS_RESERVED1_SHIFT	3
-	u8 pbl_page_size_log;
-	u8 pbe_page_size_log;
 	u8 default_cq;
+	__le16 reserved0;
 	__le32 stat_sn;
+	__le32 initial_ack;
 };
 /* iSCSI connection statistics */
 	__le32 reserved;
 };
-/* spe message header */
-struct iscsi_slow_path_hdr {
-	u8 op_code;
-	u8 flags;
-#define ISCSI_SLOW_PATH_HDR_RESERVED0_MASK	0xF
-#define ISCSI_SLOW_PATH_HDR_RESERVED0_SHIFT	0
-#define ISCSI_SLOW_PATH_HDR_LAYER_CODE_MASK	0x7
-#define ISCSI_SLOW_PATH_HDR_LAYER_CODE_SHIFT	4
-#define ISCSI_SLOW_PATH_HDR_RESERVED1_MASK	0x1
-#define ISCSI_SLOW_PATH_HDR_RESERVED1_SHIFT	7
-};
 /* iSCSI connection update params passed by driver to FW in ISCSI update
  *ramrod.
  */
 struct iscsi_conn_update_ramrod_params {
-	struct iscsi_slow_path_hdr hdr;
+	__le16 reserved0;
 	__le16 conn_id;
-	__le32 fw_cid;
+	__le32 reserved1;
 	u8 flags;
 #define ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN_MASK		0x1
 #define ISCSI_CONN_UPDATE_RAMROD_PARAMS_HD_EN_SHIFT		0
 #define ISCSI_CONN_UPDATE_RAMROD_PARAMS_DIF_ON_IMM_EN_SHIFT	6
 #define ISCSI_CONN_UPDATE_RAMROD_PARAMS_LUN_MAPPER_EN_MASK	0x1
 #define ISCSI_CONN_UPDATE_RAMROD_PARAMS_LUN_MAPPER_EN_SHIFT	7
-	u8 reserved0[3];
+	u8 reserved3[3];
 	__le32 max_seq_size;
 	__le32 max_send_pdu_length;
 	__le32 max_recv_pdu_length;
 /* iSCSI connection termination request */
 struct iscsi_spe_conn_mac_update {
-	struct iscsi_slow_path_hdr hdr;
+	__le16 reserved0;
 	__le16 conn_id;
-	__le32 fw_cid;
+	__le32 reserved1;
 	__le16 remote_mac_addr_lo;
 	__le16 remote_mac_addr_mid;
 	__le16 remote_mac_addr_hi;
-	u8 reserved0[2];
+	u8 reserved2[2];
 };
 /* iSCSI and TCP connection (Option 1) offload params passed by driver to FW in
  * iSCSI offload ramrod.
  */
 struct iscsi_spe_conn_offload {
-	struct iscsi_slow_path_hdr hdr;
+	__le16 reserved0;
 	__le16 conn_id;
-	__le32 fw_cid;
+	__le32 reserved1;
 	struct iscsi_conn_offload_params iscsi;
 	struct tcp_offload_params tcp;
 };
  * iSCSI offload ramrod.
  */
 struct iscsi_spe_conn_offload_option2 {
-	struct iscsi_slow_path_hdr hdr;
+	__le16 reserved0;
 	__le16 conn_id;
-	__le32 fw_cid;
+	__le32 reserved1;
 	struct iscsi_conn_offload_params iscsi;
 	struct tcp_offload_params_opt2 tcp;
 };
 /* iSCSI collect connection statistics request */
 struct iscsi_spe_conn_statistics {
-	struct iscsi_slow_path_hdr hdr;
+	__le16 reserved0;
 	__le16 conn_id;
-	__le32 fw_cid;
+	__le32 reserved1;
 	u8 reset_stats;
-	u8 reserved0[7];
+	u8 reserved2[7];
 	struct regpair stats_cnts_addr;
 };
 /* iSCSI connection termination request */
 struct iscsi_spe_conn_termination {
-	struct iscsi_slow_path_hdr hdr;
+	__le16 reserved0;
 	__le16 conn_id;
-	__le32 fw_cid;
+	__le32 reserved1;
 	u8 abortive;
-	u8 reserved0[7];
+	u8 reserved2[7];
 	struct regpair queue_cnts_addr;
 	struct regpair query_params_addr;
 };
-/* iSCSI firmware function destroy parameters */
-struct iscsi_spe_func_dstry {
-	struct iscsi_slow_path_hdr hdr;
-	__le16 reserved0;
-	__le32 reserved1;
-};
 /* iSCSI firmware function init parameters */
 struct iscsi_spe_func_init {
-	struct iscsi_slow_path_hdr hdr;
 	__le16 half_way_close_timeout;
 	u8 num_sq_pages_in_ring;
 	u8 num_r2tq_pages_in_ring;
 #define ISCSI_SPE_FUNC_INIT_RESERVED0_MASK	0x7F
 #define ISCSI_SPE_FUNC_INIT_RESERVED0_SHIFT	1
 	struct iscsi_debug_modes debug_mode;
-	__le16 reserved1;
+	u8 params;
-	__le32 reserved2;
+#define ISCSI_SPE_FUNC_INIT_MAX_SYN_RT_MASK	0xF
+#define ISCSI_SPE_FUNC_INIT_MAX_SYN_RT_SHIFT	0
+#define ISCSI_SPE_FUNC_INIT_RESERVED1_MASK	0xF
+#define ISCSI_SPE_FUNC_INIT_RESERVED1_SHIFT	4
+	u8 reserved2[7];
 	struct scsi_init_func_params func_params;
 	struct scsi_init_func_queues q_params;
 };

include/linux/qed/qed_if.h+13−1

 enum qed_nvm_images {
 	QED_NVM_IMAGE_ISCSI_CFG,
 	QED_NVM_IMAGE_FCOE_CFG,
+	QED_NVM_IMAGE_MDUMP,
 	QED_NVM_IMAGE_NVM_CFG1,
 	QED_NVM_IMAGE_DEFAULT_CFG,
 	QED_NVM_IMAGE_NVM_META,
 #define DIRECT_REG_RD(reg_addr) readl((void __iomem *)(reg_addr))
-#define DIRECT_REG_WR64(reg_addr, val) writeq((u32)val,	\
+#define DIRECT_REG_WR64(reg_addr, val) writeq((u64)val,	\
 					      (void __iomem *)(reg_addr))
 #define QED_COALESCE_MAX 0x1FF
 #define GET_FIELD(value, name) \
 	(((value) >> (name ## _SHIFT)) & name ## _MASK)
+#define GET_MFW_FIELD(name, field) \
+	(((name) & (field ## _MASK)) >> (field ## _OFFSET))
+#define SET_MFW_FIELD(name, field, value)				 \
+	do {								 \
+		(name) &= ~(field ## _MASK);				 \
+		(name) |= (((value) << (field ## _OFFSET)) & (field ## _MASK));\
+	} while (0)
+#define DB_ADDR_SHIFT(addr) ((addr) << DB_PWM_ADDR_OFFSET_SHIFT)
 /* Debug print definitions */
 #define DP_ERR(cdev, fmt, ...)					\
 	do {							\

include/linux/qed/qed_ll2_if.h+7−0

 	QED_LL2_TYPE_ROCE,
 	QED_LL2_TYPE_IWARP,
 	QED_LL2_TYPE_RESERVED3,
+	MAX_QED_LL2_CONN_TYPE
+};
+enum qed_ll2_rx_conn_type {
+	QED_LL2_RX_TYPE_LEGACY,
+	QED_LL2_RX_TYPE_CTX,
 	MAX_QED_LL2_RX_CONN_TYPE
 };
 };
 struct qed_ll2_acquire_data_inputs {
+	enum qed_ll2_rx_conn_type rx_conn_type;
 	enum qed_ll2_conn_type conn_type;
 	u16 mtu;
 	u16 rx_num_desc;

include/linux/qed/storage_common.h+2−1

 struct scsi_init_func_params {
 	__le16 num_tasks;
 	u8 log_page_size;
+	u8 log_page_size_conn;
 	u8 debug_mode;
-	u8 reserved2[12];
+	u8 reserved2[11];
 };
 /* SCSI RQ/CQ/CMDQ firmware function init parameters */

include/linux/sfp.h+66−29

 	__be16 cal_v_offset;
 } __packed;
+/* SFF8024 defined constants */
+enum {
+	SFF8024_ID_UNK			= 0x00,
+	SFF8024_ID_SFF_8472		= 0x02,
+	SFF8024_ID_SFP			= 0x03,
+	SFF8024_ID_DWDM_SFP		= 0x0b,
+	SFF8024_ID_QSFP_8438		= 0x0c,
+	SFF8024_ID_QSFP_8436_8636	= 0x0d,
+	SFF8024_ID_QSFP28_8636		= 0x11,
+	SFF8024_ENCODING_UNSPEC		= 0x00,
+	SFF8024_ENCODING_8B10B		= 0x01,
+	SFF8024_ENCODING_4B5B		= 0x02,
+	SFF8024_ENCODING_NRZ		= 0x03,
+	SFF8024_ENCODING_8472_MANCHESTER= 0x04,
+	SFF8024_ENCODING_8472_SONET	= 0x05,
+	SFF8024_ENCODING_8472_64B66B	= 0x06,
+	SFF8024_ENCODING_8436_MANCHESTER= 0x06,
+	SFF8024_ENCODING_8436_SONET	= 0x04,
+	SFF8024_ENCODING_8436_64B66B	= 0x05,
+	SFF8024_ENCODING_256B257B	= 0x07,
+	SFF8024_ENCODING_PAM4		= 0x08,
+	SFF8024_CONNECTOR_UNSPEC	= 0x00,
+	/* codes 01-05 not supportable on SFP, but some modules have single SC */
+	SFF8024_CONNECTOR_SC		= 0x01,
+	SFF8024_CONNECTOR_FIBERJACK	= 0x06,
+	SFF8024_CONNECTOR_LC		= 0x07,
+	SFF8024_CONNECTOR_MT_RJ		= 0x08,
+	SFF8024_CONNECTOR_MU		= 0x09,
+	SFF8024_CONNECTOR_SG		= 0x0a,
+	SFF8024_CONNECTOR_OPTICAL_PIGTAIL= 0x0b,
+	SFF8024_CONNECTOR_MPO_1X12	= 0x0c,
+	SFF8024_CONNECTOR_MPO_2X16	= 0x0d,
+	SFF8024_CONNECTOR_HSSDC_II	= 0x20,
+	SFF8024_CONNECTOR_COPPER_PIGTAIL= 0x21,
+	SFF8024_CONNECTOR_RJ45		= 0x22,
+	SFF8024_CONNECTOR_NOSEPARATE	= 0x23,
+	SFF8024_CONNECTOR_MXC_2X16	= 0x24,
+	SFF8024_ECC_UNSPEC		= 0x00,
+	SFF8024_ECC_100G_25GAUI_C2M_AOC	= 0x01,
+	SFF8024_ECC_100GBASE_SR4_25GBASE_SR = 0x02,
+	SFF8024_ECC_100GBASE_LR4_25GBASE_LR = 0x03,
+	SFF8024_ECC_100GBASE_ER4_25GBASE_ER = 0x04,
+	SFF8024_ECC_100GBASE_SR10	= 0x05,
+	SFF8024_ECC_100GBASE_CR4	= 0x0b,
+	SFF8024_ECC_25GBASE_CR_S	= 0x0c,
+	SFF8024_ECC_25GBASE_CR_N	= 0x0d,
+	SFF8024_ECC_10GBASE_T_SFI	= 0x16,
+	SFF8024_ECC_10GBASE_T_SR	= 0x1c,
+	SFF8024_ECC_5GBASE_T		= 0x1d,
+	SFF8024_ECC_2_5GBASE_T		= 0x1e,
+};
 /* SFP EEPROM registers */
 enum {
 	SFP_PHYS_ID			= 0x00,
 	SFP_SFF8472_COMPLIANCE		= 0x5e,
 	SFP_CC_EXT			= 0x5f,
-	SFP_PHYS_ID_SFF			= 0x02,
-	SFP_PHYS_ID_SFP			= 0x03,
 	SFP_PHYS_EXT_ID_SFP		= 0x04,
-	SFP_CONNECTOR_UNSPEC		= 0x00,
-	/* codes 01-05 not supportable on SFP, but some modules have single SC */
-	SFP_CONNECTOR_SC		= 0x01,
-	SFP_CONNECTOR_FIBERJACK		= 0x06,
-	SFP_CONNECTOR_LC		= 0x07,
-	SFP_CONNECTOR_MT_RJ		= 0x08,
-	SFP_CONNECTOR_MU		= 0x09,
-	SFP_CONNECTOR_SG		= 0x0a,
-	SFP_CONNECTOR_OPTICAL_PIGTAIL	= 0x0b,
-	SFP_CONNECTOR_MPO_1X12		= 0x0c,
-	SFP_CONNECTOR_MPO_2X16		= 0x0d,
-	SFP_CONNECTOR_HSSDC_II		= 0x20,
-	SFP_CONNECTOR_COPPER_PIGTAIL	= 0x21,
-	SFP_CONNECTOR_RJ45		= 0x22,
-	SFP_CONNECTOR_NOSEPARATE	= 0x23,
-	SFP_CONNECTOR_MXC_2X16		= 0x24,
-	SFP_ENCODING_UNSPEC		= 0x00,
-	SFP_ENCODING_8B10B		= 0x01,
-	SFP_ENCODING_4B5B		= 0x02,
-	SFP_ENCODING_NRZ		= 0x03,
-	SFP_ENCODING_8472_MANCHESTER	= 0x04,
-	SFP_ENCODING_8472_SONET		= 0x05,
-	SFP_ENCODING_8472_64B66B	= 0x06,
-	SFP_ENCODING_256B257B		= 0x07,
-	SFP_ENCODING_PAM4		= 0x08,
 	SFP_OPTIONS_HIGH_POWER_LEVEL	= BIT(13),
 	SFP_OPTIONS_PAGING_A2		= BIT(12),
 	SFP_OPTIONS_RETIMER		= BIT(11),
  * @module_insert: called after a module has been detected to determine
  *   whether the module is supported for the upstream device.
  * @module_remove: called after the module has been removed.
+ * @module_start: called after the PHY probe step
+ * @module_stop: called before the PHY is removed
  * @link_down: called when the link is non-operational for whatever
  *   reason.
  * @link_up: called when the link is operational.
 	void (*detach)(void *priv, struct sfp_bus *bus);
 	int (*module_insert)(void *priv, const struct sfp_eeprom_id *id);
 	void (*module_remove)(void *priv);
+	int (*module_start)(void *priv);
+	void (*module_stop)(void *priv);
 	void (*link_down)(void *priv);
 	void (*link_up)(void *priv);
 	int (*connect_phy)(void *priv, struct phy_device *);
 #if IS_ENABLED(CONFIG_SFP)
 int sfp_parse_port(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
 		   unsigned long *support);
+bool sfp_may_have_phy(struct sfp_bus *bus, const struct sfp_eeprom_id *id);
 void sfp_parse_support(struct sfp_bus *bus, const struct sfp_eeprom_id *id,
 		       unsigned long *support);
 phy_interface_t sfp_select_interface(struct sfp_bus *bus,
-				     const struct sfp_eeprom_id *id,
 				     unsigned long *link_modes);
 int sfp_get_module_info(struct sfp_bus *bus, struct ethtool_modinfo *modinfo);
 	return PORT_OTHER;
 }
+static inline bool sfp_may_have_phy(struct sfp_bus *bus,
+				    const struct sfp_eeprom_id *id)
+{
+	return false;
+}
 static inline void sfp_parse_support(struct sfp_bus *bus,
 				     const struct sfp_eeprom_id *id,
 				     unsigned long *support)
 }
 static inline phy_interface_t sfp_select_interface(struct sfp_bus *bus,
-						   const struct sfp_eeprom_id *id,
 						   unsigned long *link_modes)
 {
 	return PHY_INTERFACE_MODE_NA;

include/linux/skbuff.h+23−3

 	SKB_GSO_UDP = 1 << 16,
 	SKB_GSO_UDP_L4 = 1 << 17,
+	SKB_GSO_FRAGLIST = 1 << 18,
 };
 #if BITS_PER_LONG > 32
 	skb->next = NULL;
 }
+/* Iterate through singly-linked GSO fragments of an skb. */
+#define skb_list_walk_safe(first, skb, next_skb)                               \
+	for ((skb) = (first), (next_skb) = (skb) ? (skb)->next : NULL; (skb);  \
+	     (skb) = (next_skb), (next_skb) = (skb) ? (skb)->next : NULL)
 static inline void skb_list_del_init(struct sk_buff *skb)
 {
 	__list_del_entry(&skb->list);
 	for (iter = skb_shinfo(skb)->frag_list; iter; iter = iter->next)
-int __skb_wait_for_more_packets(struct sock *sk, int *err, long *timeo_p,
+int __skb_wait_for_more_packets(struct sock *sk, struct sk_buff_head *queue,
+				int *err, long *timeo_p,
 				const struct sk_buff *skb);
 struct sk_buff *__skb_try_recv_from_queue(struct sock *sk,
 					  struct sk_buff_head *queue,
 							   struct sk_buff *skb),
 					  int *off, int *err,
 					  struct sk_buff **last);
-struct sk_buff *__skb_try_recv_datagram(struct sock *sk, unsigned flags,
+struct sk_buff *__skb_try_recv_datagram(struct sock *sk,
+					struct sk_buff_head *queue,
+					unsigned int flags,
 					void (*destructor)(struct sock *sk,
 							   struct sk_buff *skb),
 					int *off, int *err,
 					struct sk_buff **last);
-struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
+struct sk_buff *__skb_recv_datagram(struct sock *sk,
+				    struct sk_buff_head *sk_queue,
+				    unsigned int flags,
 				    void (*destructor)(struct sock *sk,
 						       struct sk_buff *skb),
 				    int *off, int *err);
 bool skb_gso_validate_network_len(const struct sk_buff *skb, unsigned int mtu);
 bool skb_gso_validate_mac_len(const struct sk_buff *skb, unsigned int len);
 struct sk_buff *skb_segment(struct sk_buff *skb, netdev_features_t features);
+struct sk_buff *skb_segment_list(struct sk_buff *skb, netdev_features_t features,
+				 unsigned int offset);
 struct sk_buff *skb_vlan_untag(struct sk_buff *skb);
 int skb_ensure_writable(struct sk_buff *skb, int write_len);
 int __skb_vlan_pop(struct sk_buff *skb, u16 *vlan_tci);
 #endif
 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
 	TC_SKB_EXT,
+#endif
+#if IS_ENABLED(CONFIG_MPTCP)
+	SKB_EXT_MPTCP,
 #endif
 	SKB_EXT_NUM, /* must be last */
 };
 	char data[0] __aligned(8);
 };
+struct skb_ext *__skb_ext_alloc(void);
+void *__skb_ext_set(struct sk_buff *skb, enum skb_ext_id id,
+		    struct skb_ext *ext);
 void *skb_ext_add(struct sk_buff *skb, enum skb_ext_id id);
 void __skb_ext_del(struct sk_buff *skb, enum skb_ext_id id);
 void __skb_ext_put(struct skb_ext *ext);

include/linux/stmmac.h+14−0

 	bool axi_rb;
 };
+#define EST_GCL		1024
+struct stmmac_est {
+	int enable;
+	u32 btr_offset[2];
+	u32 btr[2];
+	u32 ctr[2];
+	u32 ter;
+	u32 gcl_unaligned[EST_GCL];
+	u32 gcl[EST_GCL];
+	u32 gcl_size;
+};
 struct stmmac_rxq_cfg {
 	u8 mode_to_use;
 	u32 chan;
 	u32 low_credit;
 	bool use_prio;
 	u32 prio;
+	int tbs_en;
 };
 struct plat_stmmacenet_data {
 	struct device_node *phylink_node;
 	struct device_node *mdio_node;
 	struct stmmac_dma_cfg *dma_cfg;
+	struct stmmac_est *est;
 	int clk_csr;
 	int has_gmac;
 	int enh_desc;

include/linux/tcp.h+37−0

@@ -78,6 +78,27 @@ struct tcp_sack_block { · 77 unmodified lines
78	#define TCP_SACK_SEEN (1 << 0) /1 = peer is SACK capable, /	78	#define TCP_SACK_SEEN (1 << 0) /1 = peer is SACK capable, /
79	#define TCP_DSACK_SEEN (1 << 2) /1 = DSACK was received from peer/	79	#define TCP_DSACK_SEEN (1 << 2) /1 = DSACK was received from peer/
80		80
		81	#if IS_ENABLED(CONFIG_MPTCP)
		82	struct mptcp_options_received {
		83	u64 sndr_key;
		84	u64 rcvr_key;
		85	u64 data_ack;
		86	u64 data_seq;
		87	u32 subflow_seq;
		88	u16 data_len;
		89	u8 mp_capable : 1,
		90	mp_join : 1,
		91	dss : 1;
		92	u8 use_map:1,
		93	dsn64:1,
		94	data_fin:1,
		95	use_ack:1,
		96	ack64:1,
		97	mpc_map:1,
		98	__unused:2;
		99	};
		100	#endif
		101
81	struct tcp_options_received {	102	struct tcp_options_received {
82	/* PAWS/RTTM data */	103	/* PAWS/RTTM data */
83	int ts_recent_stamp;/* Time we stored ts_recent (for aging) */	104	int ts_recent_stamp;/* Time we stored ts_recent (for aging) */
@@ -95,6 +116,9 @@ struct tcp_options_received { · 11 unmodified lines
95	u8 num_sacks; /* Number of SACK blocks */	116	u8 num_sacks; /* Number of SACK blocks */
96	u16 user_mss; /* mss requested by user in ioctl */	117	u16 user_mss; /* mss requested by user in ioctl */
97	u16 mss_clamp; /* Maximal mss, negotiated at connection setup */	118	u16 mss_clamp; /* Maximal mss, negotiated at connection setup */
		119	#if IS_ENABLED(CONFIG_MPTCP)
		120	struct mptcp_options_received mptcp;
		121	#endif
98	};	122	};
99		123
100	static inline void tcp_clear_options(struct tcp_options_received *rx_opt)	124	static inline void tcp_clear_options(struct tcp_options_received *rx_opt)
@@ -104,6 +128,11 @@ static inline void tcp_clear_options(struct tcp_options_received *rx_opt) · 3 unmodified lines
104	#if IS_ENABLED(CONFIG_SMC)	128	#if IS_ENABLED(CONFIG_SMC)
105	rx_opt->smc_ok = 0;	129	rx_opt->smc_ok = 0;
106	#endif	130	#endif
		131	#if IS_ENABLED(CONFIG_MPTCP)
		132	rx_opt->mptcp.mp_capable = 0;
		133	rx_opt->mptcp.mp_join = 0;
		134	rx_opt->mptcp.dss = 0;
		135	#endif
107	}	136	}
108		137
109	/* This is the max number of SACKS that we'll generate and process. It's safe	138	/* This is the max number of SACKS that we'll generate and process. It's safe
@@ -119,6 +148,9 @@ struct tcp_request_sock { · 9 unmodified lines
119	const struct tcp_request_sock_ops *af_specific;	148	const struct tcp_request_sock_ops *af_specific;
120	u64 snt_synack; /* first SYNACK sent time */	149	u64 snt_synack; /* first SYNACK sent time */
121	bool tfo_listener;	150	bool tfo_listener;
		151	#if IS_ENABLED(CONFIG_MPTCP)
		152	bool is_mptcp;
		153	#endif
122	u32 txhash;	154	u32 txhash;
123	u32 rcv_isn;	155	u32 rcv_isn;
124	u32 snt_isn;	156	u32 snt_isn;
@@ -354,6 +386,8 @@ struct tcp_sock { · 229 unmodified lines
354	#define BPF_SOCK_OPS_TEST_FLAG(TP, ARG) 0	386	#define BPF_SOCK_OPS_TEST_FLAG(TP, ARG) 0
355	#endif	387	#endif
356		388
		389	u16 timeout_rehash; /* Timeout-triggered rehash attempts */
		390
357	u32 rcv_ooopack; /* Received out-of-order packets, for tcpinfo */	391	u32 rcv_ooopack; /* Received out-of-order packets, for tcpinfo */
358		392
359	/* Receiver side RTT estimation */	393	/* Receiver side RTT estimation */
@@ -379,6 +413,9 @@ struct tcp_sock { · 19 unmodified lines
379	u32 mtu_info; /* We received an ICMP_FRAG_NEEDED / ICMPV6_PKT_TOOBIG	413	u32 mtu_info; /* We received an ICMP_FRAG_NEEDED / ICMPV6_PKT_TOOBIG
380	* while socket was owned by user.	414	* while socket was owned by user.
381	*/	415	*/
		416	#if IS_ENABLED(CONFIG_MPTCP)
		417	bool is_mptcp;
		418	#endif
382		419
383	#ifdef CONFIG_TCP_MD5SIG	420	#ifdef CONFIG_TCP_MD5SIG
384	/* TCP AF-Specific parts; only used by MD5 Signature support so far */	421	/* TCP AF-Specific parts; only used by MD5 Signature support so far */

include/linux/usb/usbnet.h+1−1

@@ -253,7 +253,7 @@ extern int usbnet_open(struct net_device *net); · 252 unmodified lines
253	extern int usbnet_stop(struct net_device *net);	253	extern int usbnet_stop(struct net_device *net);
254	extern netdev_tx_t usbnet_start_xmit(struct sk_buff *skb,	254	extern netdev_tx_t usbnet_start_xmit(struct sk_buff *skb,
255	struct net_device *net);	255	struct net_device *net);
256	extern void usbnet_tx_timeout(struct net_device *net);	256	extern void usbnet_tx_timeout(struct net_device *net, unsigned int txqueue);
257	extern int usbnet_change_mtu(struct net_device *net, int new_mtu);	257	extern int usbnet_change_mtu(struct net_device *net, int new_mtu);
258		258
259	extern int usbnet_get_endpoints(struct usbnet , struct usb_interface );	259	extern int usbnet_get_endpoints(struct usbnet , struct usb_interface );