From 21bd7d0e6899c4925afc56495ec1e2ed7a976f6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Adrian=20Schr=C3=B6ter?= Date: Sat, 20 Apr 2024 00:14:06 +0200 Subject: [PATCH] Sync from SUSE:ALP:Source:Standard:1.0 linux-glibc-devel revision 900eec747e8d60b06a57d89a632bf905 --- cleanup_patch.sh | 15 + linux-glibc-devel-current.patch | 56472 ++++++++++++++++++++++++++++++ linux-glibc-devel.changes | 29 + linux-glibc-devel.spec | 4 + make_diff.sh | 97 + 5 files changed, 56617 insertions(+) create mode 100644 cleanup_patch.sh create mode 100644 linux-glibc-devel-current.patch create mode 100644 make_diff.sh diff --git a/cleanup_patch.sh b/cleanup_patch.sh new file mode 100644 index 0000000..3e8d898 --- /dev/null +++ b/cleanup_patch.sh @@ -0,0 +1,15 @@ +#!/bin/sh +# +# clean up the patch via quilt again; run on linux-glibc-devel-6.4 + +patchfile="$1" +p="${patchfile##*/}" + +mkdir .pc +echo "2" > .pc/.version +mkdir patches +quilt import -p1 "$patchfile" +quilt push +quilt refresh -p ab --no-index --no-timestamps --sort +cp "patches/$p" "$patchfile" +exit 0 diff --git a/linux-glibc-devel-current.patch b/linux-glibc-devel-current.patch new file mode 100644 index 0000000..af8538c --- /dev/null +++ b/linux-glibc-devel-current.patch @@ -0,0 +1,56472 @@ +kernel-source.git: 3a5699ce249903c6a3012e1f53e5d4566d3887a4 + +--- a/alpha/usr/include/asm-generic/siginfo.h ++++ b/alpha/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/alpha/usr/include/linux/affs_hardblocks.h ++++ b/alpha/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/alpha/usr/include/linux/auto_dev-ioctl.h ++++ b/alpha/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/alpha/usr/include/linux/blkzoned.h ++++ b/alpha/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/alpha/usr/include/linux/bpf.h ++++ b/alpha/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/alpha/usr/include/linux/cn_proc.h ++++ b/alpha/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/alpha/usr/include/linux/devlink.h ++++ b/alpha/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/alpha/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/alpha/usr/include/linux/elf.h ++++ b/alpha/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/alpha/usr/include/linux/ethtool.h ++++ b/alpha/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/alpha/usr/include/linux/ethtool_netlink.h ++++ b/alpha/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/alpha/usr/include/linux/fuse.h ++++ b/alpha/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/alpha/usr/include/linux/gtp.h ++++ b/alpha/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/alpha/usr/include/linux/if_link.h ++++ b/alpha/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/alpha/usr/include/linux/if_xdp.h ++++ b/alpha/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/alpha/usr/include/linux/io_uring.h ++++ b/alpha/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/alpha/usr/include/linux/ioprio.h ++++ b/alpha/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/alpha/usr/include/linux/kfd_ioctl.h ++++ b/alpha/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/alpha/usr/include/linux/kfd_sysfs.h ++++ b/alpha/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/alpha/usr/include/linux/netdev.h ++++ b/alpha/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/alpha/usr/include/linux/netlink.h ++++ b/alpha/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/alpha/usr/include/linux/nl80211.h ++++ b/alpha/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/alpha/usr/include/linux/perf_event.h ++++ b/alpha/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/alpha/usr/include/linux/pkt_sched.h ++++ b/alpha/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/alpha/usr/include/linux/pktcdvd.h ++++ b/alpha/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/alpha/usr/include/linux/prctl.h ++++ b/alpha/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/alpha/usr/include/linux/psp-sev.h ++++ b/alpha/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/alpha/usr/include/linux/ptp_clock.h ++++ b/alpha/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/alpha/usr/include/linux/raid/md_p.h ++++ b/alpha/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/alpha/usr/include/linux/sed-opal.h ++++ b/alpha/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/alpha/usr/include/linux/sev-guest.h ++++ b/alpha/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/alpha/usr/include/linux/stddef.h ++++ b/alpha/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/alpha/usr/include/linux/sync_file.h ++++ b/alpha/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/alpha/usr/include/linux/ublk_cmd.h ++++ b/alpha/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/alpha/usr/include/linux/v4l2-controls.h ++++ b/alpha/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/alpha/usr/include/linux/v4l2-subdev.h ++++ b/alpha/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/alpha/usr/include/linux/vfio.h ++++ b/alpha/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/alpha/usr/include/linux/vhost.h ++++ b/alpha/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/alpha/usr/include/linux/vhost_types.h ++++ b/alpha/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/alpha/usr/include/linux/videodev2.h ++++ b/alpha/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/alpha/usr/include/linux/virtio_pmem.h ++++ b/alpha/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/alpha/usr/include/linux/vm_sockets.h ++++ b/alpha/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/alpha/usr/include/rdma/bnxt_re-abi.h ++++ b/alpha/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/alpha/usr/include/rdma/efa-abi.h ++++ b/alpha/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/alpha/usr/include/rdma/hns-abi.h ++++ b/alpha/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/alpha/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/alpha/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/alpha/usr/include/rdma/irdma-abi.h ++++ b/alpha/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/alpha/usr/include/rdma/mlx5-abi.h ++++ b/alpha/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/alpha/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/alpha/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/alpha/usr/include/rdma/rdma_netlink.h ++++ b/alpha/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/alpha/usr/include/rdma/siw-abi.h ++++ b/alpha/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/alpha/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/alpha/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/alpha/usr/include/sound/asequencer.h ++++ b/alpha/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/alpha/usr/include/sound/asound.h ++++ b/alpha/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/alpha/usr/include/sound/sof/tokens.h ++++ b/alpha/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/arm/usr/include/asm-generic/siginfo.h ++++ b/arm/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/arm/usr/include/linux/affs_hardblocks.h ++++ b/arm/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/arm/usr/include/linux/auto_dev-ioctl.h ++++ b/arm/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/arm/usr/include/linux/blkzoned.h ++++ b/arm/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/arm/usr/include/linux/bpf.h ++++ b/arm/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/arm/usr/include/linux/cn_proc.h ++++ b/arm/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/arm/usr/include/linux/devlink.h ++++ b/arm/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/arm/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/arm/usr/include/linux/elf.h ++++ b/arm/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/arm/usr/include/linux/ethtool.h ++++ b/arm/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/arm/usr/include/linux/ethtool_netlink.h ++++ b/arm/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/arm/usr/include/linux/fuse.h ++++ b/arm/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/arm/usr/include/linux/gtp.h ++++ b/arm/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/arm/usr/include/linux/if_link.h ++++ b/arm/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/arm/usr/include/linux/if_xdp.h ++++ b/arm/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/arm/usr/include/linux/io_uring.h ++++ b/arm/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/arm/usr/include/linux/ioprio.h ++++ b/arm/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/arm/usr/include/linux/kfd_ioctl.h ++++ b/arm/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/arm/usr/include/linux/kfd_sysfs.h ++++ b/arm/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/arm/usr/include/linux/netdev.h ++++ b/arm/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/arm/usr/include/linux/netlink.h ++++ b/arm/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/arm/usr/include/linux/nl80211.h ++++ b/arm/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/arm/usr/include/linux/perf_event.h ++++ b/arm/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/arm/usr/include/linux/pkt_sched.h ++++ b/arm/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/arm/usr/include/linux/pktcdvd.h ++++ b/arm/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/arm/usr/include/linux/prctl.h ++++ b/arm/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/arm/usr/include/linux/psp-sev.h ++++ b/arm/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/arm/usr/include/linux/ptp_clock.h ++++ b/arm/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/arm/usr/include/linux/raid/md_p.h ++++ b/arm/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/arm/usr/include/linux/sed-opal.h ++++ b/arm/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/arm/usr/include/linux/sev-guest.h ++++ b/arm/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/arm/usr/include/linux/stddef.h ++++ b/arm/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/arm/usr/include/linux/sync_file.h ++++ b/arm/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/arm/usr/include/linux/ublk_cmd.h ++++ b/arm/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/arm/usr/include/linux/v4l2-controls.h ++++ b/arm/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/arm/usr/include/linux/v4l2-subdev.h ++++ b/arm/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/arm/usr/include/linux/vfio.h ++++ b/arm/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/arm/usr/include/linux/vhost.h ++++ b/arm/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/arm/usr/include/linux/vhost_types.h ++++ b/arm/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/arm/usr/include/linux/videodev2.h ++++ b/arm/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/arm/usr/include/linux/virtio_pmem.h ++++ b/arm/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/arm/usr/include/linux/vm_sockets.h ++++ b/arm/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/arm/usr/include/rdma/bnxt_re-abi.h ++++ b/arm/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/arm/usr/include/rdma/efa-abi.h ++++ b/arm/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/arm/usr/include/rdma/hns-abi.h ++++ b/arm/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/arm/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/arm/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/arm/usr/include/rdma/irdma-abi.h ++++ b/arm/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/arm/usr/include/rdma/mlx5-abi.h ++++ b/arm/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/arm/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/arm/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/arm/usr/include/rdma/rdma_netlink.h ++++ b/arm/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/arm/usr/include/rdma/siw-abi.h ++++ b/arm/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/arm/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/arm/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/arm/usr/include/sound/asequencer.h ++++ b/arm/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/arm/usr/include/sound/asound.h ++++ b/arm/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/arm/usr/include/sound/sof/tokens.h ++++ b/arm/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/arm64/usr/include/asm-generic/siginfo.h ++++ b/arm64/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/arm64/usr/include/asm/hwcap.h ++++ b/arm64/usr/include/asm/hwcap.h +@@ -102,5 +102,6 @@ + #define HWCAP2_SME_BI32I32 (1UL << 40) + #define HWCAP2_SME_B16B16 (1UL << 41) + #define HWCAP2_SME_F16F16 (1UL << 42) ++#define HWCAP2_HBC (1UL << 44) + + #endif /* __ASM_HWCAP_H */ +--- a/arm64/usr/include/asm/sigcontext.h ++++ b/arm64/usr/include/asm/sigcontext.h +@@ -177,7 +177,7 @@ struct zt_context { + * vector length beyond its initial architectural limit of 2048 bits + * (16 quadwords). + * +- * See linux/Documentation/arm64/sve.rst for a description of the VL/VQ ++ * See linux/Documentation/arch/arm64/sve.rst for a description of the VL/VQ + * terminology. + */ + #define SVE_VQ_BYTES __SVE_VQ_BYTES /* bytes per quadword */ +--- a/arm64/usr/include/linux/affs_hardblocks.h ++++ b/arm64/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/arm64/usr/include/linux/auto_dev-ioctl.h ++++ b/arm64/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/arm64/usr/include/linux/blkzoned.h ++++ b/arm64/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/arm64/usr/include/linux/bpf.h ++++ b/arm64/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/arm64/usr/include/linux/cn_proc.h ++++ b/arm64/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/arm64/usr/include/linux/devlink.h ++++ b/arm64/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/arm64/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/arm64/usr/include/linux/elf.h ++++ b/arm64/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/arm64/usr/include/linux/ethtool.h ++++ b/arm64/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/arm64/usr/include/linux/ethtool_netlink.h ++++ b/arm64/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/arm64/usr/include/linux/fuse.h ++++ b/arm64/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/arm64/usr/include/linux/gtp.h ++++ b/arm64/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/arm64/usr/include/linux/if_link.h ++++ b/arm64/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/arm64/usr/include/linux/if_xdp.h ++++ b/arm64/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/arm64/usr/include/linux/io_uring.h ++++ b/arm64/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/arm64/usr/include/linux/ioprio.h ++++ b/arm64/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/arm64/usr/include/linux/kfd_ioctl.h ++++ b/arm64/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/arm64/usr/include/linux/kfd_sysfs.h ++++ b/arm64/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/arm64/usr/include/linux/netdev.h ++++ b/arm64/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/arm64/usr/include/linux/netlink.h ++++ b/arm64/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/arm64/usr/include/linux/nl80211.h ++++ b/arm64/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/arm64/usr/include/linux/perf_event.h ++++ b/arm64/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/arm64/usr/include/linux/pkt_sched.h ++++ b/arm64/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/arm64/usr/include/linux/pktcdvd.h ++++ b/arm64/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/arm64/usr/include/linux/prctl.h ++++ b/arm64/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/arm64/usr/include/linux/psp-sev.h ++++ b/arm64/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/arm64/usr/include/linux/ptp_clock.h ++++ b/arm64/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/arm64/usr/include/linux/raid/md_p.h ++++ b/arm64/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/arm64/usr/include/linux/sed-opal.h ++++ b/arm64/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/arm64/usr/include/linux/sev-guest.h ++++ b/arm64/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/arm64/usr/include/linux/stddef.h ++++ b/arm64/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/arm64/usr/include/linux/sync_file.h ++++ b/arm64/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/arm64/usr/include/linux/ublk_cmd.h ++++ b/arm64/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/arm64/usr/include/linux/v4l2-controls.h ++++ b/arm64/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/arm64/usr/include/linux/v4l2-subdev.h ++++ b/arm64/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/arm64/usr/include/linux/vfio.h ++++ b/arm64/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/arm64/usr/include/linux/vhost.h ++++ b/arm64/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/arm64/usr/include/linux/vhost_types.h ++++ b/arm64/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/arm64/usr/include/linux/videodev2.h ++++ b/arm64/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/arm64/usr/include/linux/virtio_pmem.h ++++ b/arm64/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/arm64/usr/include/linux/vm_sockets.h ++++ b/arm64/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/arm64/usr/include/rdma/bnxt_re-abi.h ++++ b/arm64/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/arm64/usr/include/rdma/efa-abi.h ++++ b/arm64/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/arm64/usr/include/rdma/hns-abi.h ++++ b/arm64/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/arm64/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/arm64/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/arm64/usr/include/rdma/irdma-abi.h ++++ b/arm64/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/arm64/usr/include/rdma/mlx5-abi.h ++++ b/arm64/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/arm64/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/arm64/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/arm64/usr/include/rdma/rdma_netlink.h ++++ b/arm64/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/arm64/usr/include/rdma/siw-abi.h ++++ b/arm64/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/arm64/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/arm64/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/arm64/usr/include/sound/asequencer.h ++++ b/arm64/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/arm64/usr/include/sound/asound.h ++++ b/arm64/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/arm64/usr/include/sound/sof/tokens.h ++++ b/arm64/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/ia64/usr/include/asm-generic/siginfo.h ++++ b/ia64/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/ia64/usr/include/linux/affs_hardblocks.h ++++ b/ia64/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/ia64/usr/include/linux/auto_dev-ioctl.h ++++ b/ia64/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/ia64/usr/include/linux/blkzoned.h ++++ b/ia64/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/ia64/usr/include/linux/bpf.h ++++ b/ia64/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/ia64/usr/include/linux/cn_proc.h ++++ b/ia64/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/ia64/usr/include/linux/devlink.h ++++ b/ia64/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/ia64/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/ia64/usr/include/linux/elf.h ++++ b/ia64/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/ia64/usr/include/linux/ethtool.h ++++ b/ia64/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/ia64/usr/include/linux/ethtool_netlink.h ++++ b/ia64/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/ia64/usr/include/linux/fuse.h ++++ b/ia64/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/ia64/usr/include/linux/gtp.h ++++ b/ia64/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/ia64/usr/include/linux/if_link.h ++++ b/ia64/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/ia64/usr/include/linux/if_xdp.h ++++ b/ia64/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/ia64/usr/include/linux/io_uring.h ++++ b/ia64/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/ia64/usr/include/linux/ioprio.h ++++ b/ia64/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/ia64/usr/include/linux/kfd_ioctl.h ++++ b/ia64/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/ia64/usr/include/linux/kfd_sysfs.h ++++ b/ia64/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/ia64/usr/include/linux/netdev.h ++++ b/ia64/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/ia64/usr/include/linux/netlink.h ++++ b/ia64/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/ia64/usr/include/linux/nl80211.h ++++ b/ia64/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/ia64/usr/include/linux/perf_event.h ++++ b/ia64/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/ia64/usr/include/linux/pkt_sched.h ++++ b/ia64/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/ia64/usr/include/linux/pktcdvd.h ++++ b/ia64/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/ia64/usr/include/linux/prctl.h ++++ b/ia64/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/ia64/usr/include/linux/psp-sev.h ++++ b/ia64/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/ia64/usr/include/linux/ptp_clock.h ++++ b/ia64/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/ia64/usr/include/linux/raid/md_p.h ++++ b/ia64/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/ia64/usr/include/linux/sed-opal.h ++++ b/ia64/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/ia64/usr/include/linux/sev-guest.h ++++ b/ia64/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/ia64/usr/include/linux/stddef.h ++++ b/ia64/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/ia64/usr/include/linux/sync_file.h ++++ b/ia64/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/ia64/usr/include/linux/ublk_cmd.h ++++ b/ia64/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/ia64/usr/include/linux/v4l2-controls.h ++++ b/ia64/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/ia64/usr/include/linux/v4l2-subdev.h ++++ b/ia64/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/ia64/usr/include/linux/vfio.h ++++ b/ia64/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/ia64/usr/include/linux/vhost.h ++++ b/ia64/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/ia64/usr/include/linux/vhost_types.h ++++ b/ia64/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/ia64/usr/include/linux/videodev2.h ++++ b/ia64/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/ia64/usr/include/linux/virtio_pmem.h ++++ b/ia64/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/ia64/usr/include/linux/vm_sockets.h ++++ b/ia64/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/ia64/usr/include/rdma/bnxt_re-abi.h ++++ b/ia64/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/ia64/usr/include/rdma/efa-abi.h ++++ b/ia64/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/ia64/usr/include/rdma/hns-abi.h ++++ b/ia64/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/ia64/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/ia64/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/ia64/usr/include/rdma/irdma-abi.h ++++ b/ia64/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/ia64/usr/include/rdma/mlx5-abi.h ++++ b/ia64/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/ia64/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/ia64/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/ia64/usr/include/rdma/rdma_netlink.h ++++ b/ia64/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/ia64/usr/include/rdma/siw-abi.h ++++ b/ia64/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/ia64/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/ia64/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/ia64/usr/include/sound/asequencer.h ++++ b/ia64/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/ia64/usr/include/sound/asound.h ++++ b/ia64/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/ia64/usr/include/sound/sof/tokens.h ++++ b/ia64/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/loongarch/usr/include/asm-generic/siginfo.h ++++ b/loongarch/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/loongarch/usr/include/linux/affs_hardblocks.h ++++ b/loongarch/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/loongarch/usr/include/linux/auto_dev-ioctl.h ++++ b/loongarch/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/loongarch/usr/include/linux/blkzoned.h ++++ b/loongarch/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/loongarch/usr/include/linux/bpf.h ++++ b/loongarch/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/loongarch/usr/include/linux/cn_proc.h ++++ b/loongarch/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/loongarch/usr/include/linux/devlink.h ++++ b/loongarch/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/loongarch/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/loongarch/usr/include/linux/elf.h ++++ b/loongarch/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/loongarch/usr/include/linux/ethtool.h ++++ b/loongarch/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/loongarch/usr/include/linux/ethtool_netlink.h ++++ b/loongarch/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/loongarch/usr/include/linux/fuse.h ++++ b/loongarch/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/loongarch/usr/include/linux/gtp.h ++++ b/loongarch/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/loongarch/usr/include/linux/if_link.h ++++ b/loongarch/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/loongarch/usr/include/linux/if_xdp.h ++++ b/loongarch/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/loongarch/usr/include/linux/io_uring.h ++++ b/loongarch/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/loongarch/usr/include/linux/ioprio.h ++++ b/loongarch/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/loongarch/usr/include/linux/kfd_ioctl.h ++++ b/loongarch/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/loongarch/usr/include/linux/kfd_sysfs.h ++++ b/loongarch/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/loongarch/usr/include/linux/netdev.h ++++ b/loongarch/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/loongarch/usr/include/linux/netlink.h ++++ b/loongarch/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/loongarch/usr/include/linux/nl80211.h ++++ b/loongarch/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/loongarch/usr/include/linux/perf_event.h ++++ b/loongarch/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/loongarch/usr/include/linux/pkt_sched.h ++++ b/loongarch/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/loongarch/usr/include/linux/pktcdvd.h ++++ b/loongarch/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/loongarch/usr/include/linux/prctl.h ++++ b/loongarch/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/loongarch/usr/include/linux/psp-sev.h ++++ b/loongarch/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/loongarch/usr/include/linux/ptp_clock.h ++++ b/loongarch/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/loongarch/usr/include/linux/raid/md_p.h ++++ b/loongarch/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/loongarch/usr/include/linux/sed-opal.h ++++ b/loongarch/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/loongarch/usr/include/linux/sev-guest.h ++++ b/loongarch/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/loongarch/usr/include/linux/stddef.h ++++ b/loongarch/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/loongarch/usr/include/linux/sync_file.h ++++ b/loongarch/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/loongarch/usr/include/linux/ublk_cmd.h ++++ b/loongarch/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/loongarch/usr/include/linux/v4l2-controls.h ++++ b/loongarch/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/loongarch/usr/include/linux/v4l2-subdev.h ++++ b/loongarch/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/loongarch/usr/include/linux/vfio.h ++++ b/loongarch/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/loongarch/usr/include/linux/vhost.h ++++ b/loongarch/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/loongarch/usr/include/linux/vhost_types.h ++++ b/loongarch/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/loongarch/usr/include/linux/videodev2.h ++++ b/loongarch/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/loongarch/usr/include/linux/virtio_pmem.h ++++ b/loongarch/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/loongarch/usr/include/linux/vm_sockets.h ++++ b/loongarch/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/loongarch/usr/include/rdma/bnxt_re-abi.h ++++ b/loongarch/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/loongarch/usr/include/rdma/efa-abi.h ++++ b/loongarch/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/loongarch/usr/include/rdma/hns-abi.h ++++ b/loongarch/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/loongarch/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/loongarch/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/loongarch/usr/include/rdma/irdma-abi.h ++++ b/loongarch/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/loongarch/usr/include/rdma/mlx5-abi.h ++++ b/loongarch/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/loongarch/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/loongarch/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/loongarch/usr/include/rdma/rdma_netlink.h ++++ b/loongarch/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/loongarch/usr/include/rdma/siw-abi.h ++++ b/loongarch/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/loongarch/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/loongarch/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/loongarch/usr/include/sound/asequencer.h ++++ b/loongarch/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/loongarch/usr/include/sound/asound.h ++++ b/loongarch/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/loongarch/usr/include/sound/sof/tokens.h ++++ b/loongarch/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/m68k/usr/include/asm-generic/siginfo.h ++++ b/m68k/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/m68k/usr/include/linux/affs_hardblocks.h ++++ b/m68k/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/m68k/usr/include/linux/auto_dev-ioctl.h ++++ b/m68k/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/m68k/usr/include/linux/blkzoned.h ++++ b/m68k/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/m68k/usr/include/linux/bpf.h ++++ b/m68k/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/m68k/usr/include/linux/cn_proc.h ++++ b/m68k/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/m68k/usr/include/linux/devlink.h ++++ b/m68k/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/m68k/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/m68k/usr/include/linux/elf.h ++++ b/m68k/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/m68k/usr/include/linux/ethtool.h ++++ b/m68k/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/m68k/usr/include/linux/ethtool_netlink.h ++++ b/m68k/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/m68k/usr/include/linux/fuse.h ++++ b/m68k/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/m68k/usr/include/linux/gtp.h ++++ b/m68k/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/m68k/usr/include/linux/if_link.h ++++ b/m68k/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/m68k/usr/include/linux/if_xdp.h ++++ b/m68k/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/m68k/usr/include/linux/io_uring.h ++++ b/m68k/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/m68k/usr/include/linux/ioprio.h ++++ b/m68k/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/m68k/usr/include/linux/kfd_ioctl.h ++++ b/m68k/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/m68k/usr/include/linux/kfd_sysfs.h ++++ b/m68k/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/m68k/usr/include/linux/netdev.h ++++ b/m68k/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/m68k/usr/include/linux/netlink.h ++++ b/m68k/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/m68k/usr/include/linux/nl80211.h ++++ b/m68k/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/m68k/usr/include/linux/perf_event.h ++++ b/m68k/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/m68k/usr/include/linux/pkt_sched.h ++++ b/m68k/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/m68k/usr/include/linux/pktcdvd.h ++++ b/m68k/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/m68k/usr/include/linux/prctl.h ++++ b/m68k/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/m68k/usr/include/linux/psp-sev.h ++++ b/m68k/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/m68k/usr/include/linux/ptp_clock.h ++++ b/m68k/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/m68k/usr/include/linux/raid/md_p.h ++++ b/m68k/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/m68k/usr/include/linux/sed-opal.h ++++ b/m68k/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/m68k/usr/include/linux/sev-guest.h ++++ b/m68k/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/m68k/usr/include/linux/stddef.h ++++ b/m68k/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/m68k/usr/include/linux/sync_file.h ++++ b/m68k/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/m68k/usr/include/linux/ublk_cmd.h ++++ b/m68k/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/m68k/usr/include/linux/v4l2-controls.h ++++ b/m68k/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/m68k/usr/include/linux/v4l2-subdev.h ++++ b/m68k/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/m68k/usr/include/linux/vfio.h ++++ b/m68k/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/m68k/usr/include/linux/vhost.h ++++ b/m68k/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/m68k/usr/include/linux/vhost_types.h ++++ b/m68k/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/m68k/usr/include/linux/videodev2.h ++++ b/m68k/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/m68k/usr/include/linux/virtio_pmem.h ++++ b/m68k/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/m68k/usr/include/linux/vm_sockets.h ++++ b/m68k/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/m68k/usr/include/rdma/bnxt_re-abi.h ++++ b/m68k/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/m68k/usr/include/rdma/efa-abi.h ++++ b/m68k/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/m68k/usr/include/rdma/hns-abi.h ++++ b/m68k/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/m68k/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/m68k/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/m68k/usr/include/rdma/irdma-abi.h ++++ b/m68k/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/m68k/usr/include/rdma/mlx5-abi.h ++++ b/m68k/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/m68k/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/m68k/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/m68k/usr/include/rdma/rdma_netlink.h ++++ b/m68k/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/m68k/usr/include/rdma/siw-abi.h ++++ b/m68k/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/m68k/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/m68k/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/m68k/usr/include/sound/asequencer.h ++++ b/m68k/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/m68k/usr/include/sound/asound.h ++++ b/m68k/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/m68k/usr/include/sound/sof/tokens.h ++++ b/m68k/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/mips/usr/include/asm-generic/siginfo.h ++++ b/mips/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/mips/usr/include/linux/affs_hardblocks.h ++++ b/mips/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/mips/usr/include/linux/auto_dev-ioctl.h ++++ b/mips/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/mips/usr/include/linux/blkzoned.h ++++ b/mips/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/mips/usr/include/linux/bpf.h ++++ b/mips/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/mips/usr/include/linux/cn_proc.h ++++ b/mips/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/mips/usr/include/linux/devlink.h ++++ b/mips/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/mips/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/mips/usr/include/linux/elf.h ++++ b/mips/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/mips/usr/include/linux/ethtool.h ++++ b/mips/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/mips/usr/include/linux/ethtool_netlink.h ++++ b/mips/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/mips/usr/include/linux/fuse.h ++++ b/mips/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/mips/usr/include/linux/gtp.h ++++ b/mips/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/mips/usr/include/linux/if_link.h ++++ b/mips/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/mips/usr/include/linux/if_xdp.h ++++ b/mips/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/mips/usr/include/linux/io_uring.h ++++ b/mips/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/mips/usr/include/linux/ioprio.h ++++ b/mips/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/mips/usr/include/linux/kfd_ioctl.h ++++ b/mips/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/mips/usr/include/linux/kfd_sysfs.h ++++ b/mips/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/mips/usr/include/linux/netdev.h ++++ b/mips/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/mips/usr/include/linux/netlink.h ++++ b/mips/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/mips/usr/include/linux/nl80211.h ++++ b/mips/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/mips/usr/include/linux/perf_event.h ++++ b/mips/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/mips/usr/include/linux/pkt_sched.h ++++ b/mips/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/mips/usr/include/linux/pktcdvd.h ++++ b/mips/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/mips/usr/include/linux/prctl.h ++++ b/mips/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/mips/usr/include/linux/psp-sev.h ++++ b/mips/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/mips/usr/include/linux/ptp_clock.h ++++ b/mips/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/mips/usr/include/linux/raid/md_p.h ++++ b/mips/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/mips/usr/include/linux/sed-opal.h ++++ b/mips/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/mips/usr/include/linux/sev-guest.h ++++ b/mips/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/mips/usr/include/linux/stddef.h ++++ b/mips/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/mips/usr/include/linux/sync_file.h ++++ b/mips/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/mips/usr/include/linux/ublk_cmd.h ++++ b/mips/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/mips/usr/include/linux/v4l2-controls.h ++++ b/mips/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/mips/usr/include/linux/v4l2-subdev.h ++++ b/mips/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/mips/usr/include/linux/vfio.h ++++ b/mips/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/mips/usr/include/linux/vhost.h ++++ b/mips/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/mips/usr/include/linux/vhost_types.h ++++ b/mips/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/mips/usr/include/linux/videodev2.h ++++ b/mips/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/mips/usr/include/linux/virtio_pmem.h ++++ b/mips/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/mips/usr/include/linux/vm_sockets.h ++++ b/mips/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/mips/usr/include/rdma/bnxt_re-abi.h ++++ b/mips/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/mips/usr/include/rdma/efa-abi.h ++++ b/mips/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/mips/usr/include/rdma/hns-abi.h ++++ b/mips/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/mips/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/mips/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/mips/usr/include/rdma/irdma-abi.h ++++ b/mips/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/mips/usr/include/rdma/mlx5-abi.h ++++ b/mips/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/mips/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/mips/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/mips/usr/include/rdma/rdma_netlink.h ++++ b/mips/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/mips/usr/include/rdma/siw-abi.h ++++ b/mips/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/mips/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/mips/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/mips/usr/include/sound/asequencer.h ++++ b/mips/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/mips/usr/include/sound/asound.h ++++ b/mips/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/mips/usr/include/sound/sof/tokens.h ++++ b/mips/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/parisc/usr/include/asm-generic/siginfo.h ++++ b/parisc/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/parisc/usr/include/linux/affs_hardblocks.h ++++ b/parisc/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/parisc/usr/include/linux/auto_dev-ioctl.h ++++ b/parisc/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/parisc/usr/include/linux/blkzoned.h ++++ b/parisc/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/parisc/usr/include/linux/bpf.h ++++ b/parisc/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/parisc/usr/include/linux/cn_proc.h ++++ b/parisc/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/parisc/usr/include/linux/devlink.h ++++ b/parisc/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/parisc/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/parisc/usr/include/linux/elf.h ++++ b/parisc/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/parisc/usr/include/linux/ethtool.h ++++ b/parisc/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/parisc/usr/include/linux/ethtool_netlink.h ++++ b/parisc/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/parisc/usr/include/linux/fuse.h ++++ b/parisc/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/parisc/usr/include/linux/gtp.h ++++ b/parisc/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/parisc/usr/include/linux/if_link.h ++++ b/parisc/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/parisc/usr/include/linux/if_xdp.h ++++ b/parisc/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/parisc/usr/include/linux/io_uring.h ++++ b/parisc/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/parisc/usr/include/linux/ioprio.h ++++ b/parisc/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/parisc/usr/include/linux/kfd_ioctl.h ++++ b/parisc/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/parisc/usr/include/linux/kfd_sysfs.h ++++ b/parisc/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/parisc/usr/include/linux/netdev.h ++++ b/parisc/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/parisc/usr/include/linux/netlink.h ++++ b/parisc/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/parisc/usr/include/linux/nl80211.h ++++ b/parisc/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/parisc/usr/include/linux/perf_event.h ++++ b/parisc/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/parisc/usr/include/linux/pkt_sched.h ++++ b/parisc/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/parisc/usr/include/linux/pktcdvd.h ++++ b/parisc/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/parisc/usr/include/linux/prctl.h ++++ b/parisc/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/parisc/usr/include/linux/psp-sev.h ++++ b/parisc/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/parisc/usr/include/linux/ptp_clock.h ++++ b/parisc/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/parisc/usr/include/linux/raid/md_p.h ++++ b/parisc/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/parisc/usr/include/linux/sed-opal.h ++++ b/parisc/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/parisc/usr/include/linux/sev-guest.h ++++ b/parisc/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/parisc/usr/include/linux/stddef.h ++++ b/parisc/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/parisc/usr/include/linux/sync_file.h ++++ b/parisc/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/parisc/usr/include/linux/ublk_cmd.h ++++ b/parisc/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/parisc/usr/include/linux/v4l2-controls.h ++++ b/parisc/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/parisc/usr/include/linux/v4l2-subdev.h ++++ b/parisc/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/parisc/usr/include/linux/vfio.h ++++ b/parisc/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/parisc/usr/include/linux/vhost.h ++++ b/parisc/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/parisc/usr/include/linux/vhost_types.h ++++ b/parisc/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/parisc/usr/include/linux/videodev2.h ++++ b/parisc/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/parisc/usr/include/linux/virtio_pmem.h ++++ b/parisc/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/parisc/usr/include/linux/vm_sockets.h ++++ b/parisc/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/parisc/usr/include/rdma/bnxt_re-abi.h ++++ b/parisc/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/parisc/usr/include/rdma/efa-abi.h ++++ b/parisc/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/parisc/usr/include/rdma/hns-abi.h ++++ b/parisc/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/parisc/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/parisc/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/parisc/usr/include/rdma/irdma-abi.h ++++ b/parisc/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/parisc/usr/include/rdma/mlx5-abi.h ++++ b/parisc/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/parisc/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/parisc/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/parisc/usr/include/rdma/rdma_netlink.h ++++ b/parisc/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/parisc/usr/include/rdma/siw-abi.h ++++ b/parisc/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/parisc/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/parisc/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/parisc/usr/include/sound/asequencer.h ++++ b/parisc/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/parisc/usr/include/sound/asound.h ++++ b/parisc/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/parisc/usr/include/sound/sof/tokens.h ++++ b/parisc/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/powerpc/usr/include/asm-generic/siginfo.h ++++ b/powerpc/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/powerpc/usr/include/asm/elf.h ++++ b/powerpc/usr/include/asm/elf.h +@@ -98,6 +98,8 @@ + #define ELF_NEBB 3 /* includes ebbrr, ebbhr, bescr */ + #define ELF_NPMU 5 /* includes siar, sdar, sier, mmcr2, mmcr0 */ + #define ELF_NPKEY 3 /* includes amr, iamr, uamor */ ++#define ELF_NDEXCR 2 /* includes dexcr, hdexcr */ ++#define ELF_NHASHKEYR 1 /* includes hashkeyr */ + + typedef unsigned long elf_greg_t64; + typedef elf_greg_t64 elf_gregset_t64[ELF_NGREG]; +--- /dev/null ++++ b/powerpc/usr/include/asm/papr-miscdev.h +@@ -0,0 +1,9 @@ ++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ ++#ifndef _PAPR_MISCDEV_H_ ++#define _PAPR_MISCDEV_H_ ++ ++enum { ++ PAPR_MISCDEV_IOC_ID = 0xb2, ++}; ++ ++#endif /* _PAPR_MISCDEV_H_ */ +--- /dev/null ++++ b/powerpc/usr/include/asm/papr-sysparm.h +@@ -0,0 +1,58 @@ ++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ ++#ifndef _PAPR_SYSPARM_H_ ++#define _PAPR_SYSPARM_H_ ++ ++#include ++#include ++#include ++ ++enum { ++ PAPR_SYSPARM_MAX_INPUT = 1024, ++ PAPR_SYSPARM_MAX_OUTPUT = 4000, ++}; ++ ++struct papr_sysparm_io_block { ++ __u32 parameter; ++ __u16 length; ++ char data[PAPR_SYSPARM_MAX_OUTPUT]; ++}; ++ ++/** ++ * PAPR_SYSPARM_IOC_GET - Retrieve the value of a PAPR system parameter. ++ * ++ * Uses _IOWR because of one corner case: Retrieving the value of the ++ * "OS Service Entitlement Status" parameter (60) requires the caller ++ * to supply input data (a date string) in the buffer passed to ++ * firmware. So the @length and @data of the incoming ++ * papr_sysparm_io_block are always used to initialize the work area ++ * supplied to ibm,get-system-parameter. No other parameters are known ++ * to parameterize the result this way, and callers are encouraged ++ * (but not required) to zero-initialize @length and @data in the ++ * common case. ++ * ++ * On error the contents of the ioblock are indeterminate. ++ * ++ * Return: ++ * 0: Success; @length is the length of valid data in @data, not to exceed @PAPR_SYSPARM_MAX_OUTPUT. ++ * -EIO: Platform error. (-1) ++ * -EINVAL: Incorrect data length or format. (-9999) ++ * -EPERM: The calling partition is not allowed to access this parameter. (-9002) ++ * -EOPNOTSUPP: Parameter not supported on this platform (-3) ++ */ ++#define PAPR_SYSPARM_IOC_GET _IOWR(PAPR_MISCDEV_IOC_ID, 1, struct papr_sysparm_io_block) ++ ++/** ++ * PAPR_SYSPARM_IOC_SET - Update the value of a PAPR system parameter. ++ * ++ * The contents of the ioblock are unchanged regardless of success. ++ * ++ * Return: ++ * 0: Success; the parameter has been updated. ++ * -EIO: Platform error. (-1) ++ * -EINVAL: Incorrect data length or format. (-9999) ++ * -EPERM: The calling partition is not allowed to access this parameter. (-9002) ++ * -EOPNOTSUPP: Parameter not supported on this platform (-3) ++ */ ++#define PAPR_SYSPARM_IOC_SET _IOW(PAPR_MISCDEV_IOC_ID, 2, struct papr_sysparm_io_block) ++ ++#endif /* _PAPR_SYSPARM_H_ */ +--- /dev/null ++++ b/powerpc/usr/include/asm/papr-vpd.h +@@ -0,0 +1,22 @@ ++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ ++#ifndef _PAPR_VPD_H_ ++#define _PAPR_VPD_H_ ++ ++#include ++#include ++ ++struct papr_location_code { ++ /* ++ * PAPR+ v2.13 12.3.2.4 Converged Location Code Rules - Length ++ * Restrictions. 79 characters plus nul. ++ */ ++ char str[80]; ++}; ++ ++/* ++ * ioctl for /dev/papr-vpd. Returns a VPD handle fd corresponding to ++ * the location code. ++ */ ++#define PAPR_VPD_IOC_CREATE_HANDLE _IOW(PAPR_MISCDEV_IOC_ID, 0, struct papr_location_code) ++ ++#endif /* _PAPR_VPD_H_ */ +--- a/powerpc/usr/include/linux/affs_hardblocks.h ++++ b/powerpc/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/powerpc/usr/include/linux/auto_dev-ioctl.h ++++ b/powerpc/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/powerpc/usr/include/linux/blkzoned.h ++++ b/powerpc/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/powerpc/usr/include/linux/bpf.h ++++ b/powerpc/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/powerpc/usr/include/linux/cn_proc.h ++++ b/powerpc/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/powerpc/usr/include/linux/devlink.h ++++ b/powerpc/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/powerpc/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/powerpc/usr/include/linux/elf.h ++++ b/powerpc/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/powerpc/usr/include/linux/ethtool.h ++++ b/powerpc/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/powerpc/usr/include/linux/ethtool_netlink.h ++++ b/powerpc/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/powerpc/usr/include/linux/fuse.h ++++ b/powerpc/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/powerpc/usr/include/linux/gtp.h ++++ b/powerpc/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/powerpc/usr/include/linux/if_link.h ++++ b/powerpc/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/powerpc/usr/include/linux/if_xdp.h ++++ b/powerpc/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/powerpc/usr/include/linux/io_uring.h ++++ b/powerpc/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/powerpc/usr/include/linux/ioprio.h ++++ b/powerpc/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/powerpc/usr/include/linux/kfd_ioctl.h ++++ b/powerpc/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/powerpc/usr/include/linux/kfd_sysfs.h ++++ b/powerpc/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/powerpc/usr/include/linux/netdev.h ++++ b/powerpc/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/powerpc/usr/include/linux/netlink.h ++++ b/powerpc/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/powerpc/usr/include/linux/nl80211.h ++++ b/powerpc/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/powerpc/usr/include/linux/perf_event.h ++++ b/powerpc/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/powerpc/usr/include/linux/pkt_sched.h ++++ b/powerpc/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/powerpc/usr/include/linux/pktcdvd.h ++++ b/powerpc/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/powerpc/usr/include/linux/prctl.h ++++ b/powerpc/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/powerpc/usr/include/linux/psp-sev.h ++++ b/powerpc/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/powerpc/usr/include/linux/ptp_clock.h ++++ b/powerpc/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/powerpc/usr/include/linux/raid/md_p.h ++++ b/powerpc/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/powerpc/usr/include/linux/sed-opal.h ++++ b/powerpc/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/powerpc/usr/include/linux/sev-guest.h ++++ b/powerpc/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/powerpc/usr/include/linux/stddef.h ++++ b/powerpc/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/powerpc/usr/include/linux/sync_file.h ++++ b/powerpc/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/powerpc/usr/include/linux/ublk_cmd.h ++++ b/powerpc/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/powerpc/usr/include/linux/v4l2-controls.h ++++ b/powerpc/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/powerpc/usr/include/linux/v4l2-subdev.h ++++ b/powerpc/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/powerpc/usr/include/linux/vfio.h ++++ b/powerpc/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/powerpc/usr/include/linux/vhost.h ++++ b/powerpc/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/powerpc/usr/include/linux/vhost_types.h ++++ b/powerpc/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/powerpc/usr/include/linux/videodev2.h ++++ b/powerpc/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/powerpc/usr/include/linux/virtio_pmem.h ++++ b/powerpc/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/powerpc/usr/include/linux/vm_sockets.h ++++ b/powerpc/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/powerpc/usr/include/rdma/bnxt_re-abi.h ++++ b/powerpc/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/powerpc/usr/include/rdma/efa-abi.h ++++ b/powerpc/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/powerpc/usr/include/rdma/hns-abi.h ++++ b/powerpc/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/powerpc/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/powerpc/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/powerpc/usr/include/rdma/irdma-abi.h ++++ b/powerpc/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/powerpc/usr/include/rdma/mlx5-abi.h ++++ b/powerpc/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/powerpc/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/powerpc/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/powerpc/usr/include/rdma/rdma_netlink.h ++++ b/powerpc/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/powerpc/usr/include/rdma/siw-abi.h ++++ b/powerpc/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/powerpc/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/powerpc/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/powerpc/usr/include/sound/asequencer.h ++++ b/powerpc/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/powerpc/usr/include/sound/asound.h ++++ b/powerpc/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/powerpc/usr/include/sound/sof/tokens.h ++++ b/powerpc/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/riscv/usr/include/asm-generic/siginfo.h ++++ b/riscv/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/riscv/usr/include/linux/affs_hardblocks.h ++++ b/riscv/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/riscv/usr/include/linux/auto_dev-ioctl.h ++++ b/riscv/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/riscv/usr/include/linux/blkzoned.h ++++ b/riscv/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/riscv/usr/include/linux/bpf.h ++++ b/riscv/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/riscv/usr/include/linux/cn_proc.h ++++ b/riscv/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/riscv/usr/include/linux/devlink.h ++++ b/riscv/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/riscv/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/riscv/usr/include/linux/elf.h ++++ b/riscv/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/riscv/usr/include/linux/ethtool.h ++++ b/riscv/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/riscv/usr/include/linux/ethtool_netlink.h ++++ b/riscv/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/riscv/usr/include/linux/fuse.h ++++ b/riscv/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/riscv/usr/include/linux/gtp.h ++++ b/riscv/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/riscv/usr/include/linux/if_link.h ++++ b/riscv/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/riscv/usr/include/linux/if_xdp.h ++++ b/riscv/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/riscv/usr/include/linux/io_uring.h ++++ b/riscv/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/riscv/usr/include/linux/ioprio.h ++++ b/riscv/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/riscv/usr/include/linux/kfd_ioctl.h ++++ b/riscv/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/riscv/usr/include/linux/kfd_sysfs.h ++++ b/riscv/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/riscv/usr/include/linux/netdev.h ++++ b/riscv/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/riscv/usr/include/linux/netlink.h ++++ b/riscv/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/riscv/usr/include/linux/nl80211.h ++++ b/riscv/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/riscv/usr/include/linux/perf_event.h ++++ b/riscv/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/riscv/usr/include/linux/pkt_sched.h ++++ b/riscv/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/riscv/usr/include/linux/pktcdvd.h ++++ b/riscv/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/riscv/usr/include/linux/prctl.h ++++ b/riscv/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/riscv/usr/include/linux/psp-sev.h ++++ b/riscv/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/riscv/usr/include/linux/ptp_clock.h ++++ b/riscv/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/riscv/usr/include/linux/raid/md_p.h ++++ b/riscv/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/riscv/usr/include/linux/sed-opal.h ++++ b/riscv/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/riscv/usr/include/linux/sev-guest.h ++++ b/riscv/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/riscv/usr/include/linux/stddef.h ++++ b/riscv/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/riscv/usr/include/linux/sync_file.h ++++ b/riscv/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/riscv/usr/include/linux/ublk_cmd.h ++++ b/riscv/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/riscv/usr/include/linux/v4l2-controls.h ++++ b/riscv/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/riscv/usr/include/linux/v4l2-subdev.h ++++ b/riscv/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/riscv/usr/include/linux/vfio.h ++++ b/riscv/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/riscv/usr/include/linux/vhost.h ++++ b/riscv/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/riscv/usr/include/linux/vhost_types.h ++++ b/riscv/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/riscv/usr/include/linux/videodev2.h ++++ b/riscv/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/riscv/usr/include/linux/virtio_pmem.h ++++ b/riscv/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/riscv/usr/include/linux/vm_sockets.h ++++ b/riscv/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/riscv/usr/include/rdma/bnxt_re-abi.h ++++ b/riscv/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/riscv/usr/include/rdma/efa-abi.h ++++ b/riscv/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/riscv/usr/include/rdma/hns-abi.h ++++ b/riscv/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/riscv/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/riscv/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/riscv/usr/include/rdma/irdma-abi.h ++++ b/riscv/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/riscv/usr/include/rdma/mlx5-abi.h ++++ b/riscv/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/riscv/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/riscv/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/riscv/usr/include/rdma/rdma_netlink.h ++++ b/riscv/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/riscv/usr/include/rdma/siw-abi.h ++++ b/riscv/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/riscv/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/riscv/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/riscv/usr/include/sound/asequencer.h ++++ b/riscv/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/riscv/usr/include/sound/asound.h ++++ b/riscv/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/riscv/usr/include/sound/sof/tokens.h ++++ b/riscv/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/s390/usr/include/asm-generic/siginfo.h ++++ b/s390/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/s390/usr/include/asm/kvm.h ++++ b/s390/usr/include/asm/kvm.h +@@ -159,6 +159,22 @@ struct kvm_s390_vm_cpu_subfunc { + __u8 reserved[1728]; + }; + ++#define KVM_S390_VM_CPU_PROCESSOR_UV_FEAT_GUEST 6 ++#define KVM_S390_VM_CPU_MACHINE_UV_FEAT_GUEST 7 ++ ++#define KVM_S390_VM_CPU_UV_FEAT_NR_BITS 64 ++struct kvm_s390_vm_cpu_uv_feat { ++ union { ++ struct { ++ __u64 : 4; ++ __u64 ap : 1; /* bit 4 */ ++ __u64 ap_intr : 1; /* bit 5 */ ++ __u64 : 58; ++ }; ++ __u64 feat; ++ }; ++}; ++ + /* kvm attributes for crypto */ + #define KVM_S390_VM_CRYPTO_ENABLE_AES_KW 0 + #define KVM_S390_VM_CRYPTO_ENABLE_DEA_KW 1 +--- a/s390/usr/include/asm/pkey.h ++++ b/s390/usr/include/asm/pkey.h +@@ -2,7 +2,7 @@ + /* + * Userspace interface to the pkey device driver + * +- * Copyright IBM Corp. 2017, 2019 ++ * Copyright IBM Corp. 2017, 2023 + * + * Author: Harald Freudenberger + * +@@ -26,16 +26,21 @@ + #define MAXCLRKEYSIZE 32 /* a clear key value may be up to 32 bytes */ + #define MAXAESCIPHERKEYSIZE 136 /* our aes cipher keys have always 136 bytes */ + #define MINEP11AESKEYBLOBSIZE 256 /* min EP11 AES key blob size */ +-#define MAXEP11AESKEYBLOBSIZE 320 /* max EP11 AES key blob size */ ++#define MAXEP11AESKEYBLOBSIZE 336 /* max EP11 AES key blob size */ + + /* Minimum size of a key blob */ + #define MINKEYBLOBSIZE SECKEYBLOBSIZE + + /* defines for the type field within the pkey_protkey struct */ +-#define PKEY_KEYTYPE_AES_128 1 +-#define PKEY_KEYTYPE_AES_192 2 +-#define PKEY_KEYTYPE_AES_256 3 +-#define PKEY_KEYTYPE_ECC 4 ++#define PKEY_KEYTYPE_AES_128 1 ++#define PKEY_KEYTYPE_AES_192 2 ++#define PKEY_KEYTYPE_AES_256 3 ++#define PKEY_KEYTYPE_ECC 4 ++#define PKEY_KEYTYPE_ECC_P256 5 ++#define PKEY_KEYTYPE_ECC_P384 6 ++#define PKEY_KEYTYPE_ECC_P521 7 ++#define PKEY_KEYTYPE_ECC_ED25519 8 ++#define PKEY_KEYTYPE_ECC_ED448 9 + + /* the newer ioctls use a pkey_key_type enum for type information */ + enum pkey_key_type { +--- a/s390/usr/include/asm/uvdevice.h ++++ b/s390/usr/include/asm/uvdevice.h +@@ -32,6 +32,33 @@ struct uvio_attest { + __u16 reserved136; /* 0x0136 */ + }; + ++/** ++ * uvio_uvdev_info - Information of supported functions ++ * @supp_uvio_cmds - supported IOCTLs by this device ++ * @supp_uv_cmds - supported UVCs corresponding to the IOCTL ++ * ++ * UVIO request to get information about supported request types by this ++ * uvdevice and the Ultravisor. Everything is output. Bits are in LSB0 ++ * ordering. If the bit is set in both, @supp_uvio_cmds and @supp_uv_cmds, the ++ * uvdevice and the Ultravisor support that call. ++ * ++ * Note that bit 0 (UVIO_IOCTL_UVDEV_INFO_NR) is always zero for `supp_uv_cmds` ++ * as there is no corresponding UV-call. ++ */ ++struct uvio_uvdev_info { ++ /* ++ * If bit `n` is set, this device supports the IOCTL with nr `n`. ++ */ ++ __u64 supp_uvio_cmds; ++ /* ++ * If bit `n` is set, the Ultravisor(UV) supports the UV-call ++ * corresponding to the IOCTL with nr `n` in the calling contextx (host ++ * or guest). The value is only valid if the corresponding bit in ++ * @supp_uvio_cmds is set as well. ++ */ ++ __u64 supp_uv_cmds; ++}; ++ + /* + * The following max values define an upper length for the IOCTL in/out buffers. + * However, they do not represent the maximum the Ultravisor allows which is +@@ -42,10 +69,34 @@ struct uvio_attest { + #define UVIO_ATT_ARCB_MAX_LEN 0x100000 + #define UVIO_ATT_MEASUREMENT_MAX_LEN 0x8000 + #define UVIO_ATT_ADDITIONAL_MAX_LEN 0x8000 ++#define UVIO_ADD_SECRET_MAX_LEN 0x100000 ++#define UVIO_LIST_SECRETS_LEN 0x1000 + + #define UVIO_DEVICE_NAME "uv" + #define UVIO_TYPE_UVC 'u' + +-#define UVIO_IOCTL_ATT _IOWR(UVIO_TYPE_UVC, 0x01, struct uvio_ioctl_cb) ++enum UVIO_IOCTL_NR { ++ UVIO_IOCTL_UVDEV_INFO_NR = 0x00, ++ UVIO_IOCTL_ATT_NR, ++ UVIO_IOCTL_ADD_SECRET_NR, ++ UVIO_IOCTL_LIST_SECRETS_NR, ++ UVIO_IOCTL_LOCK_SECRETS_NR, ++ /* must be the last entry */ ++ UVIO_IOCTL_NUM_IOCTLS ++}; ++ ++#define UVIO_IOCTL(nr) _IOWR(UVIO_TYPE_UVC, nr, struct uvio_ioctl_cb) ++#define UVIO_IOCTL_UVDEV_INFO UVIO_IOCTL(UVIO_IOCTL_UVDEV_INFO_NR) ++#define UVIO_IOCTL_ATT UVIO_IOCTL(UVIO_IOCTL_ATT_NR) ++#define UVIO_IOCTL_ADD_SECRET UVIO_IOCTL(UVIO_IOCTL_ADD_SECRET_NR) ++#define UVIO_IOCTL_LIST_SECRETS UVIO_IOCTL(UVIO_IOCTL_LIST_SECRETS_NR) ++#define UVIO_IOCTL_LOCK_SECRETS UVIO_IOCTL(UVIO_IOCTL_LOCK_SECRETS_NR) ++ ++#define UVIO_SUPP_CALL(nr) (1ULL << (nr)) ++#define UVIO_SUPP_UDEV_INFO UVIO_SUPP_CALL(UVIO_IOCTL_UDEV_INFO_NR) ++#define UVIO_SUPP_ATT UVIO_SUPP_CALL(UVIO_IOCTL_ATT_NR) ++#define UVIO_SUPP_ADD_SECRET UVIO_SUPP_CALL(UVIO_IOCTL_ADD_SECRET_NR) ++#define UVIO_SUPP_LIST_SECRETS UVIO_SUPP_CALL(UVIO_IOCTL_LIST_SECRETS_NR) ++#define UVIO_SUPP_LOCK_SECRETS UVIO_SUPP_CALL(UVIO_IOCTL_LOCK_SECRETS_NR) + + #endif /* __S390_ASM_UVDEVICE_H */ +--- a/s390/usr/include/linux/affs_hardblocks.h ++++ b/s390/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/s390/usr/include/linux/auto_dev-ioctl.h ++++ b/s390/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/s390/usr/include/linux/blkzoned.h ++++ b/s390/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/s390/usr/include/linux/bpf.h ++++ b/s390/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/s390/usr/include/linux/cn_proc.h ++++ b/s390/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/s390/usr/include/linux/devlink.h ++++ b/s390/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/s390/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/s390/usr/include/linux/elf.h ++++ b/s390/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/s390/usr/include/linux/ethtool.h ++++ b/s390/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/s390/usr/include/linux/ethtool_netlink.h ++++ b/s390/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/s390/usr/include/linux/fuse.h ++++ b/s390/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/s390/usr/include/linux/gtp.h ++++ b/s390/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/s390/usr/include/linux/if_link.h ++++ b/s390/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/s390/usr/include/linux/if_xdp.h ++++ b/s390/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/s390/usr/include/linux/io_uring.h ++++ b/s390/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/s390/usr/include/linux/ioprio.h ++++ b/s390/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/s390/usr/include/linux/kfd_ioctl.h ++++ b/s390/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/s390/usr/include/linux/kfd_sysfs.h ++++ b/s390/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/s390/usr/include/linux/netdev.h ++++ b/s390/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/s390/usr/include/linux/netlink.h ++++ b/s390/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/s390/usr/include/linux/nl80211.h ++++ b/s390/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/s390/usr/include/linux/perf_event.h ++++ b/s390/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/s390/usr/include/linux/pkt_sched.h ++++ b/s390/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/s390/usr/include/linux/pktcdvd.h ++++ b/s390/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/s390/usr/include/linux/prctl.h ++++ b/s390/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/s390/usr/include/linux/psp-sev.h ++++ b/s390/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/s390/usr/include/linux/ptp_clock.h ++++ b/s390/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/s390/usr/include/linux/raid/md_p.h ++++ b/s390/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/s390/usr/include/linux/sed-opal.h ++++ b/s390/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/s390/usr/include/linux/sev-guest.h ++++ b/s390/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/s390/usr/include/linux/stddef.h ++++ b/s390/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/s390/usr/include/linux/sync_file.h ++++ b/s390/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/s390/usr/include/linux/ublk_cmd.h ++++ b/s390/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/s390/usr/include/linux/v4l2-controls.h ++++ b/s390/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/s390/usr/include/linux/v4l2-subdev.h ++++ b/s390/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/s390/usr/include/linux/vfio.h ++++ b/s390/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/s390/usr/include/linux/vhost.h ++++ b/s390/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/s390/usr/include/linux/vhost_types.h ++++ b/s390/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/s390/usr/include/linux/videodev2.h ++++ b/s390/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/s390/usr/include/linux/virtio_pmem.h ++++ b/s390/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/s390/usr/include/linux/vm_sockets.h ++++ b/s390/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/s390/usr/include/rdma/bnxt_re-abi.h ++++ b/s390/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/s390/usr/include/rdma/efa-abi.h ++++ b/s390/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/s390/usr/include/rdma/hns-abi.h ++++ b/s390/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/s390/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/s390/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/s390/usr/include/rdma/irdma-abi.h ++++ b/s390/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/s390/usr/include/rdma/mlx5-abi.h ++++ b/s390/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/s390/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/s390/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/s390/usr/include/rdma/rdma_netlink.h ++++ b/s390/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/s390/usr/include/rdma/siw-abi.h ++++ b/s390/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/s390/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/s390/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/s390/usr/include/sound/asequencer.h ++++ b/s390/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/s390/usr/include/sound/asound.h ++++ b/s390/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/s390/usr/include/sound/sof/tokens.h ++++ b/s390/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/sparc/usr/include/asm-generic/siginfo.h ++++ b/sparc/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/sparc/usr/include/linux/affs_hardblocks.h ++++ b/sparc/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/sparc/usr/include/linux/auto_dev-ioctl.h ++++ b/sparc/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/sparc/usr/include/linux/blkzoned.h ++++ b/sparc/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/sparc/usr/include/linux/bpf.h ++++ b/sparc/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/sparc/usr/include/linux/cn_proc.h ++++ b/sparc/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/sparc/usr/include/linux/devlink.h ++++ b/sparc/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/sparc/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/sparc/usr/include/linux/elf.h ++++ b/sparc/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/sparc/usr/include/linux/ethtool.h ++++ b/sparc/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/sparc/usr/include/linux/ethtool_netlink.h ++++ b/sparc/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/sparc/usr/include/linux/fuse.h ++++ b/sparc/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/sparc/usr/include/linux/gtp.h ++++ b/sparc/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/sparc/usr/include/linux/if_link.h ++++ b/sparc/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/sparc/usr/include/linux/if_xdp.h ++++ b/sparc/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/sparc/usr/include/linux/io_uring.h ++++ b/sparc/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/sparc/usr/include/linux/ioprio.h ++++ b/sparc/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/sparc/usr/include/linux/kfd_ioctl.h ++++ b/sparc/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/sparc/usr/include/linux/kfd_sysfs.h ++++ b/sparc/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/sparc/usr/include/linux/netdev.h ++++ b/sparc/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/sparc/usr/include/linux/netlink.h ++++ b/sparc/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/sparc/usr/include/linux/nl80211.h ++++ b/sparc/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/sparc/usr/include/linux/perf_event.h ++++ b/sparc/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/sparc/usr/include/linux/pkt_sched.h ++++ b/sparc/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/sparc/usr/include/linux/pktcdvd.h ++++ b/sparc/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/sparc/usr/include/linux/prctl.h ++++ b/sparc/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/sparc/usr/include/linux/psp-sev.h ++++ b/sparc/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/sparc/usr/include/linux/ptp_clock.h ++++ b/sparc/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/sparc/usr/include/linux/raid/md_p.h ++++ b/sparc/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/sparc/usr/include/linux/sed-opal.h ++++ b/sparc/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/sparc/usr/include/linux/sev-guest.h ++++ b/sparc/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/sparc/usr/include/linux/stddef.h ++++ b/sparc/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/sparc/usr/include/linux/sync_file.h ++++ b/sparc/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/sparc/usr/include/linux/ublk_cmd.h ++++ b/sparc/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/sparc/usr/include/linux/v4l2-controls.h ++++ b/sparc/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/sparc/usr/include/linux/v4l2-subdev.h ++++ b/sparc/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/sparc/usr/include/linux/vfio.h ++++ b/sparc/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/sparc/usr/include/linux/vhost.h ++++ b/sparc/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/sparc/usr/include/linux/vhost_types.h ++++ b/sparc/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/sparc/usr/include/linux/videodev2.h ++++ b/sparc/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/sparc/usr/include/linux/virtio_pmem.h ++++ b/sparc/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/sparc/usr/include/linux/vm_sockets.h ++++ b/sparc/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/sparc/usr/include/rdma/bnxt_re-abi.h ++++ b/sparc/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/sparc/usr/include/rdma/efa-abi.h ++++ b/sparc/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/sparc/usr/include/rdma/hns-abi.h ++++ b/sparc/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/sparc/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/sparc/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/sparc/usr/include/rdma/irdma-abi.h ++++ b/sparc/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/sparc/usr/include/rdma/mlx5-abi.h ++++ b/sparc/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/sparc/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/sparc/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/sparc/usr/include/rdma/rdma_netlink.h ++++ b/sparc/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/sparc/usr/include/rdma/siw-abi.h ++++ b/sparc/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/sparc/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/sparc/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/sparc/usr/include/sound/asequencer.h ++++ b/sparc/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/sparc/usr/include/sound/asound.h ++++ b/sparc/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/sparc/usr/include/sound/sof/tokens.h ++++ b/sparc/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 +--- a/x86/usr/include/asm-generic/siginfo.h ++++ b/x86/usr/include/asm-generic/siginfo.h +@@ -242,7 +242,8 @@ typedef struct siginfo { + #define SEGV_ADIPERR 7 /* Precise MCD exception */ + #define SEGV_MTEAERR 8 /* Asynchronous ARM MTE error */ + #define SEGV_MTESERR 9 /* Synchronous ARM MTE exception */ +-#define NSIGSEGV 9 ++#define SEGV_CPERR 10 /* Control protection fault */ ++#define NSIGSEGV 10 + + /* + * SIGBUS si_codes +--- a/x86/usr/include/asm/amd_hsmp.h ++++ b/x86/usr/include/asm/amd_hsmp.h +@@ -47,6 +47,9 @@ enum hsmp_message_ids { + HSMP_SET_PCI_RATE, /* 20h Control link rate on PCIe devices */ + HSMP_SET_POWER_MODE, /* 21h Select power efficiency profile policy */ + HSMP_SET_PSTATE_MAX_MIN, /* 22h Set the max and min DF P-State */ ++ HSMP_GET_METRIC_TABLE_VER, /* 23h Get metrics table version */ ++ HSMP_GET_METRIC_TABLE, /* 24h Get metrics table */ ++ HSMP_GET_METRIC_TABLE_DRAM_ADDR,/* 25h Get metrics table dram address */ + HSMP_MSG_ID_MAX, + }; + +@@ -64,6 +67,14 @@ enum hsmp_msg_type { + HSMP_GET = 1, + }; + ++enum hsmp_proto_versions { ++ HSMP_PROTO_VER2 = 2, ++ HSMP_PROTO_VER3, ++ HSMP_PROTO_VER4, ++ HSMP_PROTO_VER5, ++ HSMP_PROTO_VER6 ++}; ++ + struct hsmp_msg_desc { + int num_args; + int response_sz; +@@ -295,6 +306,104 @@ static const struct hsmp_msg_desc hsmp_m + * input: args[0] = min df pstate[15:8] + max df pstate[7:0] + */ + {1, 0, HSMP_SET}, ++ ++ /* ++ * HSMP_GET_METRIC_TABLE_VER, num_args = 0, response_sz = 1 ++ * output: args[0] = metrics table version ++ */ ++ {0, 1, HSMP_GET}, ++ ++ /* ++ * HSMP_GET_METRIC_TABLE, num_args = 0, response_sz = 0 ++ */ ++ {0, 0, HSMP_GET}, ++ ++ /* ++ * HSMP_GET_METRIC_TABLE_DRAM_ADDR, num_args = 0, response_sz = 2 ++ * output: args[0] = lower 32 bits of the address ++ * output: args[1] = upper 32 bits of the address ++ */ ++ {0, 2, HSMP_GET}, ++}; ++ ++/* Metrics table (supported only with proto version 6) */ ++struct hsmp_metric_table { ++ __u32 accumulation_counter; ++ ++ /* TEMPERATURE */ ++ __u32 max_socket_temperature; ++ __u32 max_vr_temperature; ++ __u32 max_hbm_temperature; ++ __u64 max_socket_temperature_acc; ++ __u64 max_vr_temperature_acc; ++ __u64 max_hbm_temperature_acc; ++ ++ /* POWER */ ++ __u32 socket_power_limit; ++ __u32 max_socket_power_limit; ++ __u32 socket_power; ++ ++ /* ENERGY */ ++ __u64 timestamp; ++ __u64 socket_energy_acc; ++ __u64 ccd_energy_acc; ++ __u64 xcd_energy_acc; ++ __u64 aid_energy_acc; ++ __u64 hbm_energy_acc; ++ ++ /* FREQUENCY */ ++ __u32 cclk_frequency_limit; ++ __u32 gfxclk_frequency_limit; ++ __u32 fclk_frequency; ++ __u32 uclk_frequency; ++ __u32 socclk_frequency[4]; ++ __u32 vclk_frequency[4]; ++ __u32 dclk_frequency[4]; ++ __u32 lclk_frequency[4]; ++ __u64 gfxclk_frequency_acc[8]; ++ __u64 cclk_frequency_acc[96]; ++ ++ /* FREQUENCY RANGE */ ++ __u32 max_cclk_frequency; ++ __u32 min_cclk_frequency; ++ __u32 max_gfxclk_frequency; ++ __u32 min_gfxclk_frequency; ++ __u32 fclk_frequency_table[4]; ++ __u32 uclk_frequency_table[4]; ++ __u32 socclk_frequency_table[4]; ++ __u32 vclk_frequency_table[4]; ++ __u32 dclk_frequency_table[4]; ++ __u32 lclk_frequency_table[4]; ++ __u32 max_lclk_dpm_range; ++ __u32 min_lclk_dpm_range; ++ ++ /* XGMI */ ++ __u32 xgmi_width; ++ __u32 xgmi_bitrate; ++ __u64 xgmi_read_bandwidth_acc[8]; ++ __u64 xgmi_write_bandwidth_acc[8]; ++ ++ /* ACTIVITY */ ++ __u32 socket_c0_residency; ++ __u32 socket_gfx_busy; ++ __u32 dram_bandwidth_utilization; ++ __u64 socket_c0_residency_acc; ++ __u64 socket_gfx_busy_acc; ++ __u64 dram_bandwidth_acc; ++ __u32 max_dram_bandwidth; ++ __u64 dram_bandwidth_utilization_acc; ++ __u64 pcie_bandwidth_acc[4]; ++ ++ /* THROTTLERS */ ++ __u32 prochot_residency_acc; ++ __u32 ppt_residency_acc; ++ __u32 socket_thm_residency_acc; ++ __u32 vr_thm_residency_acc; ++ __u32 hbm_thm_residency_acc; ++ __u32 spare; ++ ++ /* New items at the end to maintain driver compatibility */ ++ __u32 gfxclk_frequency[8]; + }; + + /* Reset to default packing */ +--- a/x86/usr/include/asm/bootparam.h ++++ b/x86/usr/include/asm/bootparam.h +@@ -13,7 +13,8 @@ + #define SETUP_CC_BLOB 7 + #define SETUP_IMA 8 + #define SETUP_RNG_SEED 9 +-#define SETUP_ENUM_MAX SETUP_RNG_SEED ++#define SETUP_EFI_SECRET_KEY 16 ++#define SETUP_ENUM_MAX SETUP_EFI_SECRET_KEY + + #define SETUP_INDIRECT (1<<31) + #define SETUP_TYPE_MAX (SETUP_ENUM_MAX | SETUP_INDIRECT) +--- a/x86/usr/include/asm/mman.h ++++ b/x86/usr/include/asm/mman.h +@@ -3,14 +3,10 @@ + #define _ASM_X86_MMAN_H + + #define MAP_32BIT 0x40 /* only give out 32bit addresses */ ++#define MAP_ABOVE4G 0x80 /* only map above 4GB */ + +-#ifdef CONFIG_X86_INTEL_MEMORY_PROTECTION_KEYS +-#define arch_calc_vm_prot_bits(prot, key) ( \ +- ((key) & 0x1 ? VM_PKEY_BIT0 : 0) | \ +- ((key) & 0x2 ? VM_PKEY_BIT1 : 0) | \ +- ((key) & 0x4 ? VM_PKEY_BIT2 : 0) | \ +- ((key) & 0x8 ? VM_PKEY_BIT3 : 0)) +-#endif ++/* Flags for map_shadow_stack(2) */ ++#define SHADOW_STACK_SET_TOKEN (1ULL << 0) /* Set up a restore token in the shadow stack */ + + #include + +--- a/x86/usr/include/asm/mtrr.h ++++ b/x86/usr/include/asm/mtrr.h +@@ -81,14 +81,6 @@ typedef __u8 mtrr_type; + #define MTRR_NUM_FIXED_RANGES 88 + #define MTRR_MAX_VAR_RANGES 256 + +-struct mtrr_state_type { +- struct mtrr_var_range var_ranges[MTRR_MAX_VAR_RANGES]; +- mtrr_type fixed_ranges[MTRR_NUM_FIXED_RANGES]; +- unsigned char enabled; +- unsigned char have_fixed; +- mtrr_type def_type; +-}; +- + #define MTRRphysBase_MSR(reg) (0x200 + 2 * (reg)) + #define MTRRphysMask_MSR(reg) (0x200 + 2 * (reg) + 1) + +@@ -115,9 +107,9 @@ struct mtrr_state_type { + #define MTRR_NUM_TYPES 7 + + /* +- * Invalid MTRR memory type. mtrr_type_lookup() returns this value when +- * MTRRs are disabled. Note, this value is allocated from the reserved +- * values (0x7-0xff) of the MTRR memory types. ++ * Invalid MTRR memory type. No longer used outside of MTRR code. ++ * Note, this value is allocated from the reserved values (0x7-0xff) of ++ * the MTRR memory types. + */ + #define MTRR_TYPE_INVALID 0xff + +--- a/x86/usr/include/asm/prctl.h ++++ b/x86/usr/include/asm/prctl.h +@@ -23,9 +23,21 @@ + #define ARCH_MAP_VDSO_32 0x2002 + #define ARCH_MAP_VDSO_64 0x2003 + ++/* Don't use 0x3001-0x3004 because of old glibcs */ ++ + #define ARCH_GET_UNTAG_MASK 0x4001 + #define ARCH_ENABLE_TAGGED_ADDR 0x4002 + #define ARCH_GET_MAX_TAG_BITS 0x4003 + #define ARCH_FORCE_TAGGED_SVA 0x4004 + ++#define ARCH_SHSTK_ENABLE 0x5001 ++#define ARCH_SHSTK_DISABLE 0x5002 ++#define ARCH_SHSTK_LOCK 0x5003 ++#define ARCH_SHSTK_UNLOCK 0x5004 ++#define ARCH_SHSTK_STATUS 0x5005 ++ ++/* ARCH_SHSTK_ features bits */ ++#define ARCH_SHSTK_SHSTK (1ULL << 0) ++#define ARCH_SHSTK_WRSS (1ULL << 1) ++ + #endif /* _ASM_X86_PRCTL_H */ +--- a/x86/usr/include/asm/unistd_64.h ++++ b/x86/usr/include/asm/unistd_64.h +@@ -363,6 +363,7 @@ + #define __NR_process_mrelease 448 + #define __NR_futex_waitv 449 + #define __NR_set_mempolicy_home_node 450 ++#define __NR_map_shadow_stack 453 + + + #endif /* _ASM_UNISTD_64_H */ +--- a/x86/usr/include/linux/affs_hardblocks.h ++++ b/x86/usr/include/linux/affs_hardblocks.h +@@ -7,42 +7,42 @@ + /* Just the needed definitions for the RDB of an Amiga HD. */ + + struct RigidDiskBlock { +- __u32 rdb_ID; ++ __be32 rdb_ID; + __be32 rdb_SummedLongs; +- __s32 rdb_ChkSum; +- __u32 rdb_HostID; ++ __be32 rdb_ChkSum; ++ __be32 rdb_HostID; + __be32 rdb_BlockBytes; +- __u32 rdb_Flags; +- __u32 rdb_BadBlockList; ++ __be32 rdb_Flags; ++ __be32 rdb_BadBlockList; + __be32 rdb_PartitionList; +- __u32 rdb_FileSysHeaderList; +- __u32 rdb_DriveInit; +- __u32 rdb_Reserved1[6]; +- __u32 rdb_Cylinders; +- __u32 rdb_Sectors; +- __u32 rdb_Heads; +- __u32 rdb_Interleave; +- __u32 rdb_Park; +- __u32 rdb_Reserved2[3]; +- __u32 rdb_WritePreComp; +- __u32 rdb_ReducedWrite; +- __u32 rdb_StepRate; +- __u32 rdb_Reserved3[5]; +- __u32 rdb_RDBBlocksLo; +- __u32 rdb_RDBBlocksHi; +- __u32 rdb_LoCylinder; +- __u32 rdb_HiCylinder; +- __u32 rdb_CylBlocks; +- __u32 rdb_AutoParkSeconds; +- __u32 rdb_HighRDSKBlock; +- __u32 rdb_Reserved4; ++ __be32 rdb_FileSysHeaderList; ++ __be32 rdb_DriveInit; ++ __be32 rdb_Reserved1[6]; ++ __be32 rdb_Cylinders; ++ __be32 rdb_Sectors; ++ __be32 rdb_Heads; ++ __be32 rdb_Interleave; ++ __be32 rdb_Park; ++ __be32 rdb_Reserved2[3]; ++ __be32 rdb_WritePreComp; ++ __be32 rdb_ReducedWrite; ++ __be32 rdb_StepRate; ++ __be32 rdb_Reserved3[5]; ++ __be32 rdb_RDBBlocksLo; ++ __be32 rdb_RDBBlocksHi; ++ __be32 rdb_LoCylinder; ++ __be32 rdb_HiCylinder; ++ __be32 rdb_CylBlocks; ++ __be32 rdb_AutoParkSeconds; ++ __be32 rdb_HighRDSKBlock; ++ __be32 rdb_Reserved4; + char rdb_DiskVendor[8]; + char rdb_DiskProduct[16]; + char rdb_DiskRevision[4]; + char rdb_ControllerVendor[8]; + char rdb_ControllerProduct[16]; + char rdb_ControllerRevision[4]; +- __u32 rdb_Reserved5[10]; ++ __be32 rdb_Reserved5[10]; + }; + + #define IDNAME_RIGIDDISK 0x5244534B /* "RDSK" */ +@@ -50,16 +50,16 @@ struct RigidDiskBlock { + struct PartitionBlock { + __be32 pb_ID; + __be32 pb_SummedLongs; +- __s32 pb_ChkSum; +- __u32 pb_HostID; ++ __be32 pb_ChkSum; ++ __be32 pb_HostID; + __be32 pb_Next; +- __u32 pb_Flags; +- __u32 pb_Reserved1[2]; +- __u32 pb_DevFlags; ++ __be32 pb_Flags; ++ __be32 pb_Reserved1[2]; ++ __be32 pb_DevFlags; + __u8 pb_DriveName[32]; +- __u32 pb_Reserved2[15]; ++ __be32 pb_Reserved2[15]; + __be32 pb_Environment[17]; +- __u32 pb_EReserved[15]; ++ __be32 pb_EReserved[15]; + }; + + #define IDNAME_PARTITION 0x50415254 /* "PART" */ +--- a/x86/usr/include/linux/auto_dev-ioctl.h ++++ b/x86/usr/include/linux/auto_dev-ioctl.h +@@ -109,7 +109,7 @@ struct autofs_dev_ioctl { + struct args_ismountpoint ismountpoint; + }; + +- char path[0]; ++ char path[]; + }; + + static __inline__ void init_autofs_dev_ioctl(struct autofs_dev_ioctl *in) +--- a/x86/usr/include/linux/blkzoned.h ++++ b/x86/usr/include/linux/blkzoned.h +@@ -51,13 +51,13 @@ enum blk_zone_type { + * + * The Zone Condition state machine in the ZBC/ZAC standards maps the above + * deinitions as: +- * - ZC1: Empty | BLK_ZONE_EMPTY ++ * - ZC1: Empty | BLK_ZONE_COND_EMPTY + * - ZC2: Implicit Open | BLK_ZONE_COND_IMP_OPEN + * - ZC3: Explicit Open | BLK_ZONE_COND_EXP_OPEN +- * - ZC4: Closed | BLK_ZONE_CLOSED +- * - ZC5: Full | BLK_ZONE_FULL +- * - ZC6: Read Only | BLK_ZONE_READONLY +- * - ZC7: Offline | BLK_ZONE_OFFLINE ++ * - ZC4: Closed | BLK_ZONE_COND_CLOSED ++ * - ZC5: Full | BLK_ZONE_COND_FULL ++ * - ZC6: Read Only | BLK_ZONE_COND_READONLY ++ * - ZC7: Offline | BLK_ZONE_COND_OFFLINE + * + * Conditions 0x5 to 0xC are reserved by the current ZBC/ZAC spec and should + * be considered invalid. +--- a/x86/usr/include/linux/bpf.h ++++ b/x86/usr/include/linux/bpf.h +@@ -19,6 +19,7 @@ + + /* ld/ldx fields */ + #define BPF_DW 0x18 /* double word (64-bit) */ ++#define BPF_MEMSX 0x80 /* load with sign extension */ + #define BPF_ATOMIC 0xc0 /* atomic memory ops - op type in immediate */ + #define BPF_XADD 0xc0 /* exclusive add - legacy name */ + +@@ -1036,6 +1037,9 @@ enum bpf_attach_type { + BPF_LSM_CGROUP, + BPF_STRUCT_OPS, + BPF_NETFILTER, ++ BPF_TCX_INGRESS, ++ BPF_TCX_EGRESS, ++ BPF_TRACE_UPROBE_MULTI, + __MAX_BPF_ATTACH_TYPE + }; + +@@ -1053,10 +1057,21 @@ enum bpf_link_type { + BPF_LINK_TYPE_KPROBE_MULTI = 8, + BPF_LINK_TYPE_STRUCT_OPS = 9, + BPF_LINK_TYPE_NETFILTER = 10, +- ++ BPF_LINK_TYPE_TCX = 11, ++ BPF_LINK_TYPE_UPROBE_MULTI = 12, + MAX_BPF_LINK_TYPE, + }; + ++enum bpf_perf_event_type { ++ BPF_PERF_EVENT_UNSPEC = 0, ++ BPF_PERF_EVENT_UPROBE = 1, ++ BPF_PERF_EVENT_URETPROBE = 2, ++ BPF_PERF_EVENT_KPROBE = 3, ++ BPF_PERF_EVENT_KRETPROBE = 4, ++ BPF_PERF_EVENT_TRACEPOINT = 5, ++ BPF_PERF_EVENT_EVENT = 6, ++}; ++ + /* cgroup-bpf attach flags used in BPF_PROG_ATTACH command + * + * NONE(default): No further bpf programs allowed in the subtree. +@@ -1103,7 +1118,12 @@ enum bpf_link_type { + */ + #define BPF_F_ALLOW_OVERRIDE (1U << 0) + #define BPF_F_ALLOW_MULTI (1U << 1) ++/* Generic attachment flags. */ + #define BPF_F_REPLACE (1U << 2) ++#define BPF_F_BEFORE (1U << 3) ++#define BPF_F_AFTER (1U << 4) ++#define BPF_F_ID (1U << 5) ++#define BPF_F_LINK BPF_F_LINK /* 1 << 13 */ + + /* If BPF_F_STRICT_ALIGNMENT is used in BPF_PROG_LOAD command, the + * verifier will perform strict alignment checking as if the kernel +@@ -1168,7 +1188,21 @@ enum bpf_link_type { + /* link_create.kprobe_multi.flags used in LINK_CREATE command for + * BPF_TRACE_KPROBE_MULTI attach type to create return probe. + */ +-#define BPF_F_KPROBE_MULTI_RETURN (1U << 0) ++enum { ++ BPF_F_KPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.uprobe_multi.flags used in LINK_CREATE command for ++ * BPF_TRACE_UPROBE_MULTI attach type to create return probe. ++ */ ++enum { ++ BPF_F_UPROBE_MULTI_RETURN = (1U << 0) ++}; ++ ++/* link_create.netfilter.flags used in LINK_CREATE command for ++ * BPF_PROG_TYPE_NETFILTER to enable IP packet defragmentation. ++ */ ++#define BPF_F_NETFILTER_IP_DEFRAG (1U << 0) + + /* When BPF ldimm64's insn[0].src_reg != 0 then this can have + * the following extensions: +@@ -1273,6 +1307,9 @@ enum { + + /* Create a map that will be registered/unregesitered by the backed bpf_link */ + BPF_F_LINK = (1U << 13), ++ ++/* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */ ++ BPF_F_PATH_FD = (1U << 14), + }; + + /* Flags for BPF_PROG_QUERY. */ +@@ -1421,17 +1458,29 @@ union bpf_attr { + __aligned_u64 pathname; + __u32 bpf_fd; + __u32 file_flags; ++ /* Same as dirfd in openat() syscall; see openat(2) ++ * manpage for details of path FD and pathname semantics; ++ * path_fd should accompanied by BPF_F_PATH_FD flag set in ++ * file_flags field, otherwise it should be set to zero; ++ * if BPF_F_PATH_FD flag is not set, AT_FDCWD is assumed. ++ */ ++ __s32 path_fd; + }; + + struct { /* anonymous struct used by BPF_PROG_ATTACH/DETACH commands */ +- __u32 target_fd; /* container object to attach to */ +- __u32 attach_bpf_fd; /* eBPF program to attach */ ++ union { ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; ++ __u32 attach_bpf_fd; + __u32 attach_type; + __u32 attach_flags; +- __u32 replace_bpf_fd; /* previously attached eBPF +- * program to replace if +- * BPF_F_REPLACE is used +- */ ++ __u32 replace_bpf_fd; ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; + }; + + struct { /* anonymous struct used by BPF_PROG_TEST_RUN command */ +@@ -1477,16 +1526,26 @@ union bpf_attr { + } info; + + struct { /* anonymous struct used by BPF_PROG_QUERY command */ +- __u32 target_fd; /* container object to query */ ++ union { ++ __u32 target_fd; /* target object to query or ... */ ++ __u32 target_ifindex; /* target ifindex */ ++ }; + __u32 attach_type; + __u32 query_flags; + __u32 attach_flags; + __aligned_u64 prog_ids; +- __u32 prog_cnt; ++ union { ++ __u32 prog_cnt; ++ __u32 count; ++ }; ++ __u32 :32; + /* output: per-program attach_flags. + * not allowed to be set during effective query. + */ + __aligned_u64 prog_attach_flags; ++ __aligned_u64 link_ids; ++ __aligned_u64 link_attach_flags; ++ __u64 revision; + } query; + + struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */ +@@ -1529,13 +1588,13 @@ union bpf_attr { + __u32 map_fd; /* struct_ops to attach */ + }; + union { +- __u32 target_fd; /* object to attach to */ +- __u32 target_ifindex; /* target ifindex */ ++ __u32 target_fd; /* target object to attach to or ... */ ++ __u32 target_ifindex; /* target ifindex */ + }; + __u32 attach_type; /* attach type */ + __u32 flags; /* extra flags */ + union { +- __u32 target_btf_id; /* btf_id of target to attach to */ ++ __u32 target_btf_id; /* btf_id of target to attach to */ + struct { + __aligned_u64 iter_info; /* extra bpf_iter_link_info */ + __u32 iter_info_len; /* iter_info length */ +@@ -1569,6 +1628,22 @@ union bpf_attr { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ union { ++ __u32 relative_fd; ++ __u32 relative_id; ++ }; ++ __u64 expected_revision; ++ } tcx; ++ struct { ++ __aligned_u64 path; ++ __aligned_u64 offsets; ++ __aligned_u64 ref_ctr_offsets; ++ __aligned_u64 cookies; ++ __u32 cnt; ++ __u32 flags; ++ __u32 pid; ++ } uprobe_multi; + }; + } link_create; + +@@ -1887,7 +1962,9 @@ union bpf_attr { + * performed again, if the helper is used in combination with + * direct packet access. + * Return +- * 0 on success, or a negative error in case of failure. ++ * 0 on success, or a negative error in case of failure. Positive ++ * error indicates a potential drop or congestion in the target ++ * device. The particular positive error codes are not defined. + * + * u64 bpf_get_current_pid_tgid(void) + * Description +@@ -3168,6 +3245,10 @@ union bpf_attr { + * **BPF_FIB_LOOKUP_DIRECT** + * Do a direct table lookup vs full lookup using FIB + * rules. ++ * **BPF_FIB_LOOKUP_TBID** ++ * Used with BPF_FIB_LOOKUP_DIRECT. ++ * Use the routing table ID present in *params*->tbid ++ * for the fib lookup. + * **BPF_FIB_LOOKUP_OUTPUT** + * Perform lookup from an egress perspective (default is + * ingress). +@@ -4145,9 +4226,6 @@ union bpf_attr { + * **-EOPNOTSUPP** if the operation is not supported, for example + * a call from outside of TC ingress. + * +- * **-ESOCKTNOSUPPORT** if the socket type is not supported +- * (reuseport). +- * + * long bpf_sk_assign(struct bpf_sk_lookup *ctx, struct bpf_sock *sk, u64 flags) + * Description + * Helper is overloaded depending on BPF program type. This +@@ -5030,9 +5108,14 @@ union bpf_attr { + * u64 bpf_get_func_ip(void *ctx) + * Description + * Get address of the traced function (for tracing and kprobe programs). ++ * ++ * When called for kprobe program attached as uprobe it returns ++ * probe address for both entry and return uprobe. ++ * + * Return +- * Address of the traced function. ++ * Address of the traced function for kprobe. + * 0 for kprobes placed within the function (not at the entry). ++ * Address of the probe for uprobe and return uprobe. + * + * u64 bpf_get_attach_cookie(void *ctx) + * Description +@@ -6173,6 +6256,19 @@ struct bpf_sock_tuple { + }; + }; + ++/* (Simplified) user return codes for tcx prog type. ++ * A valid tcx program must return one of these defined values. All other ++ * return codes are reserved for future use. Must remain compatible with ++ * their TC_ACT_* counter-parts. For compatibility in behavior, unknown ++ * return codes are mapped to TCX_NEXT. ++ */ ++enum tcx_action_base { ++ TCX_NEXT = -1, ++ TCX_PASS = 0, ++ TCX_DROP = 2, ++ TCX_REDIRECT = 7, ++}; ++ + struct bpf_xdp_sock { + __u32 queue_id; + }; +@@ -6425,6 +6521,40 @@ struct bpf_link_info { + __s32 priority; + __u32 flags; + } netfilter; ++ struct { ++ __aligned_u64 addrs; ++ __u32 count; /* in/out: kprobe_multi function count */ ++ __u32 flags; ++ } kprobe_multi; ++ struct { ++ __u32 type; /* enum bpf_perf_event_type */ ++ __u32 :32; ++ union { ++ struct { ++ __aligned_u64 file_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from file_name */ ++ } uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */ ++ struct { ++ __aligned_u64 func_name; /* in/out */ ++ __u32 name_len; ++ __u32 offset; /* offset from func_name */ ++ __u64 addr; ++ } kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */ ++ struct { ++ __aligned_u64 tp_name; /* in/out */ ++ __u32 name_len; ++ } tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */ ++ struct { ++ __u64 config; ++ __u32 type; ++ } event; /* BPF_PERF_EVENT_EVENT */ ++ }; ++ } perf_event; ++ struct { ++ __u32 ifindex; ++ __u32 attach_type; ++ } tcx; + }; + } __attribute__((aligned(8))); + +@@ -6822,6 +6952,7 @@ enum { + BPF_FIB_LOOKUP_DIRECT = (1U << 0), + BPF_FIB_LOOKUP_OUTPUT = (1U << 1), + BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2), ++ BPF_FIB_LOOKUP_TBID = (1U << 3), + }; + + enum { +@@ -6882,9 +7013,19 @@ struct bpf_fib_lookup { + __u32 ipv6_dst[4]; /* in6_addr; network order */ + }; + +- /* output */ +- __be16 h_vlan_proto; +- __be16 h_vlan_TCI; ++ union { ++ struct { ++ /* output */ ++ __be16 h_vlan_proto; ++ __be16 h_vlan_TCI; ++ }; ++ /* input: when accompanied with the ++ * 'BPF_FIB_LOOKUP_DIRECT | BPF_FIB_LOOKUP_TBID` flags, a ++ * specific routing table to use for the fib lookup. ++ */ ++ __u32 tbid; ++ }; ++ + __u8 smac[6]; /* ETH_ALEN */ + __u8 dmac[6]; /* ETH_ALEN */ + }; +@@ -6987,6 +7128,7 @@ struct bpf_list_head { + struct bpf_list_node { + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_rb_root { +@@ -6998,6 +7140,7 @@ struct bpf_rb_node { + __u64 :64; + __u64 :64; + __u64 :64; ++ __u64 :64; + } __attribute__((aligned(8))); + + struct bpf_refcount { +--- a/x86/usr/include/linux/cn_proc.h ++++ b/x86/usr/include/linux/cn_proc.h +@@ -30,6 +30,49 @@ enum proc_cn_mcast_op { + PROC_CN_MCAST_IGNORE = 2 + }; + ++#define PROC_EVENT_ALL (PROC_EVENT_FORK | PROC_EVENT_EXEC | PROC_EVENT_UID | \ ++ PROC_EVENT_GID | PROC_EVENT_SID | PROC_EVENT_PTRACE | \ ++ PROC_EVENT_COMM | PROC_EVENT_NONZERO_EXIT | \ ++ PROC_EVENT_COREDUMP | PROC_EVENT_EXIT) ++ ++/* ++ * If you add an entry in proc_cn_event, make sure you add it in ++ * PROC_EVENT_ALL above as well. ++ */ ++enum proc_cn_event { ++ /* Use successive bits so the enums can be used to record ++ * sets of events as well ++ */ ++ PROC_EVENT_NONE = 0x00000000, ++ PROC_EVENT_FORK = 0x00000001, ++ PROC_EVENT_EXEC = 0x00000002, ++ PROC_EVENT_UID = 0x00000004, ++ PROC_EVENT_GID = 0x00000040, ++ PROC_EVENT_SID = 0x00000080, ++ PROC_EVENT_PTRACE = 0x00000100, ++ PROC_EVENT_COMM = 0x00000200, ++ /* "next" should be 0x00000400 */ ++ /* "last" is the last process event: exit, ++ * while "next to last" is coredumping event ++ * before that is report only if process dies ++ * with non-zero exit status ++ */ ++ PROC_EVENT_NONZERO_EXIT = 0x20000000, ++ PROC_EVENT_COREDUMP = 0x40000000, ++ PROC_EVENT_EXIT = 0x80000000 ++}; ++ ++struct proc_input { ++ enum proc_cn_mcast_op mcast_op; ++ enum proc_cn_event event_type; ++}; ++ ++static __inline__ enum proc_cn_event valid_event(enum proc_cn_event ev_type) ++{ ++ ev_type &= PROC_EVENT_ALL; ++ return ev_type; ++} ++ + /* + * From the user's point of view, the process + * ID is the thread group ID and thread ID is the internal +@@ -44,24 +87,7 @@ enum proc_cn_mcast_op { + */ + + struct proc_event { +- enum what { +- /* Use successive bits so the enums can be used to record +- * sets of events as well +- */ +- PROC_EVENT_NONE = 0x00000000, +- PROC_EVENT_FORK = 0x00000001, +- PROC_EVENT_EXEC = 0x00000002, +- PROC_EVENT_UID = 0x00000004, +- PROC_EVENT_GID = 0x00000040, +- PROC_EVENT_SID = 0x00000080, +- PROC_EVENT_PTRACE = 0x00000100, +- PROC_EVENT_COMM = 0x00000200, +- /* "next" should be 0x00000400 */ +- /* "last" is the last process event: exit, +- * while "next to last" is coredumping event */ +- PROC_EVENT_COREDUMP = 0x40000000, +- PROC_EVENT_EXIT = 0x80000000 +- } what; ++ enum proc_cn_event what; + __u32 cpu; + __u64 __attribute__((aligned(8))) timestamp_ns; + /* Number of nano seconds since system boot */ +--- a/x86/usr/include/linux/devlink.h ++++ b/x86/usr/include/linux/devlink.h +@@ -661,6 +661,8 @@ enum devlink_resource_unit { + enum devlink_port_fn_attr_cap { + DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT, + DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT, ++ DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT, + + /* Add new caps above */ + __DEVLINK_PORT_FN_ATTR_CAPS_MAX, +@@ -669,6 +671,8 @@ enum devlink_port_fn_attr_cap { + #define DEVLINK_PORT_FN_CAP_ROCE _BITUL(DEVLINK_PORT_FN_ATTR_CAP_ROCE_BIT) + #define DEVLINK_PORT_FN_CAP_MIGRATABLE \ + _BITUL(DEVLINK_PORT_FN_ATTR_CAP_MIGRATABLE_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_CRYPTO _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_CRYPTO_BIT) ++#define DEVLINK_PORT_FN_CAP_IPSEC_PACKET _BITUL(DEVLINK_PORT_FN_ATTR_CAP_IPSEC_PACKET_BIT) + + enum devlink_port_function_attr { + DEVLINK_PORT_FUNCTION_ATTR_UNSPEC, +@@ -676,6 +680,7 @@ enum devlink_port_function_attr { + DEVLINK_PORT_FN_ATTR_STATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_OPSTATE, /* u8 */ + DEVLINK_PORT_FN_ATTR_CAPS, /* bitfield32 */ ++ DEVLINK_PORT_FN_ATTR_DEVLINK, /* nested */ + + __DEVLINK_PORT_FUNCTION_ATTR_MAX, + DEVLINK_PORT_FUNCTION_ATTR_MAX = __DEVLINK_PORT_FUNCTION_ATTR_MAX - 1 +--- /dev/null ++++ b/x86/usr/include/linux/dpll.h +@@ -0,0 +1,208 @@ ++/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) */ ++/* Do not edit directly, auto-generated from: */ ++/* Documentation/netlink/specs/dpll.yaml */ ++/* YNL-GEN uapi header */ ++ ++#ifndef _LINUX_DPLL_H ++#define _LINUX_DPLL_H ++ ++#define DPLL_FAMILY_NAME "dpll" ++#define DPLL_FAMILY_VERSION 1 ++ ++/** ++ * enum dpll_mode - working modes a dpll can support, differentiates if and how ++ * dpll selects one of its inputs to syntonize with it, valid values for ++ * DPLL_A_MODE attribute ++ * @DPLL_MODE_MANUAL: input can be only selected by sending a request to dpll ++ * @DPLL_MODE_AUTOMATIC: highest prio input pin auto selected by dpll ++ */ ++enum dpll_mode { ++ DPLL_MODE_MANUAL = 1, ++ DPLL_MODE_AUTOMATIC, ++ ++ /* private: */ ++ __DPLL_MODE_MAX, ++ DPLL_MODE_MAX = (__DPLL_MODE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_lock_status - provides information of dpll device lock status, ++ * valid values for DPLL_A_LOCK_STATUS attribute ++ * @DPLL_LOCK_STATUS_UNLOCKED: dpll was not yet locked to any valid input (or ++ * forced by setting DPLL_A_MODE to DPLL_MODE_DETACHED) ++ * @DPLL_LOCK_STATUS_LOCKED: dpll is locked to a valid signal, but no holdover ++ * available ++ * @DPLL_LOCK_STATUS_LOCKED_HO_ACQ: dpll is locked and holdover acquired ++ * @DPLL_LOCK_STATUS_HOLDOVER: dpll is in holdover state - lost a valid lock or ++ * was forced by disconnecting all the pins (latter possible only when dpll ++ * lock-state was already DPLL_LOCK_STATUS_LOCKED_HO_ACQ, if dpll lock-state ++ * was not DPLL_LOCK_STATUS_LOCKED_HO_ACQ, the dpll's lock-state shall remain ++ * DPLL_LOCK_STATUS_UNLOCKED) ++ */ ++enum dpll_lock_status { ++ DPLL_LOCK_STATUS_UNLOCKED = 1, ++ DPLL_LOCK_STATUS_LOCKED, ++ DPLL_LOCK_STATUS_LOCKED_HO_ACQ, ++ DPLL_LOCK_STATUS_HOLDOVER, ++ ++ /* private: */ ++ __DPLL_LOCK_STATUS_MAX, ++ DPLL_LOCK_STATUS_MAX = (__DPLL_LOCK_STATUS_MAX - 1) ++}; ++ ++#define DPLL_TEMP_DIVIDER 1000 ++ ++/** ++ * enum dpll_type - type of dpll, valid values for DPLL_A_TYPE attribute ++ * @DPLL_TYPE_PPS: dpll produces Pulse-Per-Second signal ++ * @DPLL_TYPE_EEC: dpll drives the Ethernet Equipment Clock ++ */ ++enum dpll_type { ++ DPLL_TYPE_PPS = 1, ++ DPLL_TYPE_EEC, ++ ++ /* private: */ ++ __DPLL_TYPE_MAX, ++ DPLL_TYPE_MAX = (__DPLL_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_type - defines possible types of a pin, valid values for ++ * DPLL_A_PIN_TYPE attribute ++ * @DPLL_PIN_TYPE_MUX: aggregates another layer of selectable pins ++ * @DPLL_PIN_TYPE_EXT: external input ++ * @DPLL_PIN_TYPE_SYNCE_ETH_PORT: ethernet port PHY's recovered clock ++ * @DPLL_PIN_TYPE_INT_OSCILLATOR: device internal oscillator ++ * @DPLL_PIN_TYPE_GNSS: GNSS recovered clock ++ */ ++enum dpll_pin_type { ++ DPLL_PIN_TYPE_MUX = 1, ++ DPLL_PIN_TYPE_EXT, ++ DPLL_PIN_TYPE_SYNCE_ETH_PORT, ++ DPLL_PIN_TYPE_INT_OSCILLATOR, ++ DPLL_PIN_TYPE_GNSS, ++ ++ /* private: */ ++ __DPLL_PIN_TYPE_MAX, ++ DPLL_PIN_TYPE_MAX = (__DPLL_PIN_TYPE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_direction - defines possible direction of a pin, valid values ++ * for DPLL_A_PIN_DIRECTION attribute ++ * @DPLL_PIN_DIRECTION_INPUT: pin used as a input of a signal ++ * @DPLL_PIN_DIRECTION_OUTPUT: pin used to output the signal ++ */ ++enum dpll_pin_direction { ++ DPLL_PIN_DIRECTION_INPUT = 1, ++ DPLL_PIN_DIRECTION_OUTPUT, ++ ++ /* private: */ ++ __DPLL_PIN_DIRECTION_MAX, ++ DPLL_PIN_DIRECTION_MAX = (__DPLL_PIN_DIRECTION_MAX - 1) ++}; ++ ++#define DPLL_PIN_FREQUENCY_1_HZ 1 ++#define DPLL_PIN_FREQUENCY_10_KHZ 10000 ++#define DPLL_PIN_FREQUENCY_77_5_KHZ 77500 ++#define DPLL_PIN_FREQUENCY_10_MHZ 10000000 ++ ++/** ++ * enum dpll_pin_state - defines possible states of a pin, valid values for ++ * DPLL_A_PIN_STATE attribute ++ * @DPLL_PIN_STATE_CONNECTED: pin connected, active input of phase locked loop ++ * @DPLL_PIN_STATE_DISCONNECTED: pin disconnected, not considered as a valid ++ * input ++ * @DPLL_PIN_STATE_SELECTABLE: pin enabled for automatic input selection ++ */ ++enum dpll_pin_state { ++ DPLL_PIN_STATE_CONNECTED = 1, ++ DPLL_PIN_STATE_DISCONNECTED, ++ DPLL_PIN_STATE_SELECTABLE, ++ ++ /* private: */ ++ __DPLL_PIN_STATE_MAX, ++ DPLL_PIN_STATE_MAX = (__DPLL_PIN_STATE_MAX - 1) ++}; ++ ++/** ++ * enum dpll_pin_capabilities - defines possible capabilities of a pin, valid ++ * flags on DPLL_A_PIN_CAPABILITIES attribute ++ * @DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE: pin direction can be changed ++ * @DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE: pin priority can be changed ++ * @DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE: pin state can be changed ++ */ ++enum dpll_pin_capabilities { ++ DPLL_PIN_CAPABILITIES_DIRECTION_CAN_CHANGE = 1, ++ DPLL_PIN_CAPABILITIES_PRIORITY_CAN_CHANGE = 2, ++ DPLL_PIN_CAPABILITIES_STATE_CAN_CHANGE = 4, ++}; ++ ++#define DPLL_PHASE_OFFSET_DIVIDER 1000 ++ ++enum dpll_a { ++ DPLL_A_ID = 1, ++ DPLL_A_MODULE_NAME, ++ DPLL_A_PAD, ++ DPLL_A_CLOCK_ID, ++ DPLL_A_MODE, ++ DPLL_A_MODE_SUPPORTED, ++ DPLL_A_LOCK_STATUS, ++ DPLL_A_TEMP, ++ DPLL_A_TYPE, ++ ++ __DPLL_A_MAX, ++ DPLL_A_MAX = (__DPLL_A_MAX - 1) ++}; ++ ++enum dpll_a_pin { ++ DPLL_A_PIN_ID = 1, ++ DPLL_A_PIN_PARENT_ID, ++ DPLL_A_PIN_MODULE_NAME, ++ DPLL_A_PIN_PAD, ++ DPLL_A_PIN_CLOCK_ID, ++ DPLL_A_PIN_BOARD_LABEL, ++ DPLL_A_PIN_PANEL_LABEL, ++ DPLL_A_PIN_PACKAGE_LABEL, ++ DPLL_A_PIN_TYPE, ++ DPLL_A_PIN_DIRECTION, ++ DPLL_A_PIN_FREQUENCY, ++ DPLL_A_PIN_FREQUENCY_SUPPORTED, ++ DPLL_A_PIN_FREQUENCY_MIN, ++ DPLL_A_PIN_FREQUENCY_MAX, ++ DPLL_A_PIN_PRIO, ++ DPLL_A_PIN_STATE, ++ DPLL_A_PIN_CAPABILITIES, ++ DPLL_A_PIN_PARENT_DEVICE, ++ DPLL_A_PIN_PARENT_PIN, ++ DPLL_A_PIN_PHASE_ADJUST_MIN, ++ DPLL_A_PIN_PHASE_ADJUST_MAX, ++ DPLL_A_PIN_PHASE_ADJUST, ++ DPLL_A_PIN_PHASE_OFFSET, ++ DPLL_A_PIN_FRACTIONAL_FREQUENCY_OFFSET, ++ ++ __DPLL_A_PIN_MAX, ++ DPLL_A_PIN_MAX = (__DPLL_A_PIN_MAX - 1) ++}; ++ ++enum dpll_cmd { ++ DPLL_CMD_DEVICE_ID_GET = 1, ++ DPLL_CMD_DEVICE_GET, ++ DPLL_CMD_DEVICE_SET, ++ DPLL_CMD_DEVICE_CREATE_NTF, ++ DPLL_CMD_DEVICE_DELETE_NTF, ++ DPLL_CMD_DEVICE_CHANGE_NTF, ++ DPLL_CMD_PIN_ID_GET, ++ DPLL_CMD_PIN_GET, ++ DPLL_CMD_PIN_SET, ++ DPLL_CMD_PIN_CREATE_NTF, ++ DPLL_CMD_PIN_DELETE_NTF, ++ DPLL_CMD_PIN_CHANGE_NTF, ++ ++ __DPLL_CMD_MAX, ++ DPLL_CMD_MAX = (__DPLL_CMD_MAX - 1) ++}; ++ ++#define DPLL_MCGRP_MONITOR "monitor" ++ ++#endif /* _LINUX_DPLL_H */ +--- a/x86/usr/include/linux/elf.h ++++ b/x86/usr/include/linux/elf.h +@@ -372,7 +372,8 @@ typedef struct elf64_shdr { + * Notes used in ET_CORE. Architectures export some of the arch register sets + * using the corresponding note types via the PTRACE_GETREGSET and + * PTRACE_SETREGSET requests. +- * The note name for all these is "LINUX". ++ * The note name for these types is "LINUX", except NT_PRFPREG that is named ++ * "CORE". + */ + #define NT_PRSTATUS 1 + #define NT_PRFPREG 2 +@@ -403,9 +404,13 @@ typedef struct elf64_shdr { + #define NT_PPC_TM_CPPR 0x10e /* TM checkpointed Program Priority Register */ + #define NT_PPC_TM_CDSCR 0x10f /* TM checkpointed Data Stream Control Register */ + #define NT_PPC_PKEY 0x110 /* Memory Protection Keys registers */ ++#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers */ ++#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register */ + #define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ + #define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ + #define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ ++/* Old binutils treats 0x203 as a CET state */ ++#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ + #define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ + #define NT_S390_TIMER 0x301 /* s390 timer register */ + #define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +--- a/x86/usr/include/linux/ethtool.h ++++ b/x86/usr/include/linux/ethtool.h +@@ -1264,6 +1264,8 @@ struct ethtool_rxfh_indir { + * hardware hash key. + * @hfunc: Defines the current RSS hash function used by HW (or to be set to). + * Valid values are one of the %ETH_RSS_HASH_*. ++ * @input_xfrm: Defines how the input data is transformed. Valid values are one ++ * of %RXH_XFRM_*. + * @rsvd8: Reserved for future use; see the note on reserved space. + * @rsvd32: Reserved for future use; see the note on reserved space. + * @rss_config: RX ring/queue index for each hash value i.e., indirection table +@@ -1283,7 +1285,8 @@ struct ethtool_rxfh { + __u32 indir_size; + __u32 key_size; + __u8 hfunc; +- __u8 rsvd8[3]; ++ __u8 input_xfrm; ++ __u8 rsvd8[2]; + __u32 rsvd32; + __u32 rss_config[]; + }; +@@ -1990,6 +1993,15 @@ static __inline__ int ethtool_validate_d + + #define WOL_MODE_COUNT 8 + ++/* RSS hash function data ++ * XOR the corresponding source and destination fields of each specified ++ * protocol. Both copies of the XOR'ed fields are fed into the RSS and RXHASH ++ * calculation. Note that this XORing reduces the input set entropy and could ++ * be exploited to reduce the RSS queue spread. ++ */ ++#define RXH_XFRM_SYM_XOR (1 << 0) ++#define RXH_XFRM_NO_CHANGE 0xff ++ + /* L2-L4 network traffic flow types */ + #define TCP_V4_FLOW 0x01 /* hash or spec (tcp_ip4_spec) */ + #define UDP_V4_FLOW 0x02 /* hash or spec (udp_ip4_spec) */ +--- a/x86/usr/include/linux/ethtool_netlink.h ++++ b/x86/usr/include/linux/ethtool_netlink.h +@@ -908,6 +908,7 @@ enum { + ETHTOOL_A_RSS_HFUNC, /* u32 */ + ETHTOOL_A_RSS_INDIR, /* binary */ + ETHTOOL_A_RSS_HKEY, /* binary */ ++ ETHTOOL_A_RSS_INPUT_XFRM, /* u32 */ + + __ETHTOOL_A_RSS_CNT, + ETHTOOL_A_RSS_MAX = (__ETHTOOL_A_RSS_CNT - 1), +--- a/x86/usr/include/linux/fuse.h ++++ b/x86/usr/include/linux/fuse.h +@@ -206,6 +206,7 @@ + * - add extension header + * - add FUSE_EXT_GROUPS + * - add FUSE_CREATE_SUPP_GROUP ++ * - add FUSE_HAS_EXPIRE_ONLY + */ + + #ifndef _LINUX_FUSE_H +@@ -365,6 +366,7 @@ struct fuse_file_lock { + * FUSE_HAS_INODE_DAX: use per inode DAX + * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir, + * symlink and mknod (single group that matches parent) ++ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation + */ + #define FUSE_ASYNC_READ (1 << 0) + #define FUSE_POSIX_LOCKS (1 << 1) +@@ -402,6 +404,7 @@ struct fuse_file_lock { + #define FUSE_SECURITY_CTX (1ULL << 32) + #define FUSE_HAS_INODE_DAX (1ULL << 33) + #define FUSE_CREATE_SUPP_GROUP (1ULL << 34) ++#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35) + + /** + * CUSE INIT request/reply flags +--- a/x86/usr/include/linux/gtp.h ++++ b/x86/usr/include/linux/gtp.h +@@ -33,6 +33,6 @@ enum gtp_attrs { + GTPA_PAD, + __GTPA_MAX, + }; +-#define GTPA_MAX (__GTPA_MAX + 1) ++#define GTPA_MAX (__GTPA_MAX - 1) + + #endif /* _LINUX_GTP_H_ */ +--- a/x86/usr/include/linux/if_link.h ++++ b/x86/usr/include/linux/if_link.h +@@ -376,7 +376,7 @@ enum { + + IFLA_GSO_IPV4_MAX_SIZE, + IFLA_GRO_IPV4_MAX_SIZE, +- ++ IFLA_DPLL_PIN, + __IFLA_MAX + }; + +--- a/x86/usr/include/linux/if_xdp.h ++++ b/x86/usr/include/linux/if_xdp.h +@@ -25,9 +25,21 @@ + * application. + */ + #define XDP_USE_NEED_WAKEUP (1 << 3) ++/* By setting this option, userspace application indicates that it can ++ * handle multiple descriptors per packet thus enabling AF_XDP to split ++ * multi-buffer XDP frames into multiple Rx descriptors. Without this set ++ * such frames will be dropped. ++ */ ++#define XDP_USE_SG (1 << 4) + + /* Flags for xsk_umem_config flags */ +-#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++#define XDP_UMEM_UNALIGNED_CHUNK_FLAG (1 << 0) ++ ++/* Force checksum calculation in software. Can be used for testing or ++ * working around potential HW issues. This option causes performance ++ * degradation and only works in XDP_COPY mode. ++ */ ++#define XDP_UMEM_TX_SW_CSUM (1 << 1) + + struct sockaddr_xdp { + __u16 sxdp_family; +@@ -70,6 +82,7 @@ struct xdp_umem_reg { + __u32 chunk_size; + __u32 headroom; + __u32 flags; ++ __u32 tx_metadata_len; + }; + + struct xdp_statistics { +@@ -99,6 +112,41 @@ struct xdp_options { + #define XSK_UNALIGNED_BUF_ADDR_MASK \ + ((1ULL << XSK_UNALIGNED_BUF_OFFSET_SHIFT) - 1) + ++/* Request transmit timestamp. Upon completion, put it into tx_timestamp ++ * field of struct xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_TIMESTAMP (1 << 0) ++ ++/* Request transmit checksum offload. Checksum start position and offset ++ * are communicated via csum_start and csum_offset fields of struct ++ * xsk_tx_metadata. ++ */ ++#define XDP_TXMD_FLAGS_CHECKSUM (1 << 1) ++ ++/* AF_XDP offloads request. 'request' union member is consumed by the driver ++ * when the packet is being transmitted. 'completion' union member is ++ * filled by the driver when the transmit completion arrives. ++ */ ++struct xsk_tx_metadata { ++ __u64 flags; ++ ++ union { ++ struct { ++ /* XDP_TXMD_FLAGS_CHECKSUM */ ++ ++ /* Offset from desc->addr where checksumming should start. */ ++ __u16 csum_start; ++ /* Offset from csum_start where checksum should be stored. */ ++ __u16 csum_offset; ++ } request; ++ ++ struct { ++ /* XDP_TXMD_FLAGS_TIMESTAMP */ ++ __u64 tx_timestamp; ++ } completion; ++ }; ++}; ++ + /* Rx/Tx descriptor */ + struct xdp_desc { + __u64 addr; +@@ -108,4 +156,14 @@ struct xdp_desc { + + /* UMEM descriptor is __u64 */ + ++/* Flag indicating that the packet continues with the buffer pointed out by the ++ * next frame in the ring. The end of the packet is signalled by setting this ++ * bit to zero. For single buffer packets, every descriptor has 'options' set ++ * to 0 and this maintains backward compatibility. ++ */ ++#define XDP_PKT_CONTD (1 << 0) ++ ++/* TX packet carries valid metadata. */ ++#define XDP_TX_METADATA (1 << 1) ++ + #endif /* _LINUX_IF_XDP_H */ +--- a/x86/usr/include/linux/io_uring.h ++++ b/x86/usr/include/linux/io_uring.h +@@ -173,6 +173,23 @@ enum { + */ + #define IORING_SETUP_DEFER_TASKRUN (1U << 13) + ++/* ++ * Application provides the memory for the rings ++ */ ++#define IORING_SETUP_NO_MMAP (1U << 14) ++ ++/* ++ * Register the ring fd in itself for use with ++ * IORING_REGISTER_USE_REGISTERED_RING; return a registered fd index rather ++ * than an fd. ++ */ ++#define IORING_SETUP_REGISTERED_FD_ONLY (1U << 15) ++ ++/* ++ * Removes indirection through the SQ index array. ++ */ ++#define IORING_SETUP_NO_SQARRAY (1U << 16) ++ + enum io_uring_op { + IORING_OP_NOP, + IORING_OP_READV, +@@ -223,17 +240,19 @@ enum io_uring_op { + IORING_OP_URING_CMD, + IORING_OP_SEND_ZC, + IORING_OP_SENDMSG_ZC, ++ IORING_OP_READ_MULTISHOT, + + /* this goes last, obviously */ + IORING_OP_LAST, + }; + + /* +- * sqe->uring_cmd_flags ++ * sqe->uring_cmd_flags top 8bits aren't available for userspace + * IORING_URING_CMD_FIXED use registered buffer; pass this flag + * along with setting sqe->buf_index. + */ + #define IORING_URING_CMD_FIXED (1U << 0) ++#define IORING_URING_CMD_MASK IORING_URING_CMD_FIXED + + + /* +@@ -285,11 +304,15 @@ enum io_uring_op { + * request 'user_data' + * IORING_ASYNC_CANCEL_ANY Match any request + * IORING_ASYNC_CANCEL_FD_FIXED 'fd' passed in is a fixed descriptor ++ * IORING_ASYNC_CANCEL_USERDATA Match on user_data, default for no other key ++ * IORING_ASYNC_CANCEL_OP Match request based on opcode + */ + #define IORING_ASYNC_CANCEL_ALL (1U << 0) + #define IORING_ASYNC_CANCEL_FD (1U << 1) + #define IORING_ASYNC_CANCEL_ANY (1U << 2) + #define IORING_ASYNC_CANCEL_FD_FIXED (1U << 3) ++#define IORING_ASYNC_CANCEL_USERDATA (1U << 4) ++#define IORING_ASYNC_CANCEL_OP (1U << 5) + + /* + * send/sendmsg and recv/recvmsg flags (sqe->ioprio) +@@ -406,7 +429,7 @@ struct io_sqring_offsets { + __u32 dropped; + __u32 array; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -425,7 +448,7 @@ struct io_cqring_offsets { + __u32 cqes; + __u32 flags; + __u32 resv1; +- __u64 resv2; ++ __u64 user_addr; + }; + + /* +@@ -683,7 +706,9 @@ struct io_uring_sync_cancel_reg { + __s32 fd; + __u32 flags; + struct __kernel_timespec timeout; +- __u64 pad[4]; ++ __u8 opcode; ++ __u8 pad[7]; ++ __u64 pad2[3]; + }; + + /* +--- a/x86/usr/include/linux/ioprio.h ++++ b/x86/usr/include/linux/ioprio.h +@@ -2,22 +2,23 @@ + #ifndef _LINUX_IOPRIO_H + #define _LINUX_IOPRIO_H + ++#include ++#include ++ + /* + * Gives us 8 prio classes with 13-bits of data for each class + */ + #define IOPRIO_CLASS_SHIFT 13 +-#define IOPRIO_CLASS_MASK 0x07 ++#define IOPRIO_NR_CLASSES 8 ++#define IOPRIO_CLASS_MASK (IOPRIO_NR_CLASSES - 1) + #define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1) + + #define IOPRIO_PRIO_CLASS(ioprio) \ + (((ioprio) >> IOPRIO_CLASS_SHIFT) & IOPRIO_CLASS_MASK) + #define IOPRIO_PRIO_DATA(ioprio) ((ioprio) & IOPRIO_PRIO_MASK) +-#define IOPRIO_PRIO_VALUE(class, data) \ +- ((((class) & IOPRIO_CLASS_MASK) << IOPRIO_CLASS_SHIFT) | \ +- ((data) & IOPRIO_PRIO_MASK)) + + /* +- * These are the io priority groups as implemented by the BFQ and mq-deadline ++ * These are the io priority classes as implemented by the BFQ and mq-deadline + * schedulers. RT is the realtime class, it always gets premium service. For + * ATA disks supporting NCQ IO priority, RT class IOs will be processed using + * high priority NCQ commands. BE is the best-effort scheduling class, the +@@ -25,18 +26,30 @@ + * served when no one else is using the disk. + */ + enum { +- IOPRIO_CLASS_NONE, +- IOPRIO_CLASS_RT, +- IOPRIO_CLASS_BE, +- IOPRIO_CLASS_IDLE, ++ IOPRIO_CLASS_NONE = 0, ++ IOPRIO_CLASS_RT = 1, ++ IOPRIO_CLASS_BE = 2, ++ IOPRIO_CLASS_IDLE = 3, ++ ++ /* Special class to indicate an invalid ioprio value */ ++ IOPRIO_CLASS_INVALID = 7, + }; + + /* +- * The RT and BE priority classes both support up to 8 priority levels. ++ * The RT and BE priority classes both support up to 8 priority levels that ++ * can be specified using the lower 3-bits of the priority data. + */ +-#define IOPRIO_NR_LEVELS 8 +-#define IOPRIO_BE_NR IOPRIO_NR_LEVELS ++#define IOPRIO_LEVEL_NR_BITS 3 ++#define IOPRIO_NR_LEVELS (1 << IOPRIO_LEVEL_NR_BITS) ++#define IOPRIO_LEVEL_MASK (IOPRIO_NR_LEVELS - 1) ++#define IOPRIO_PRIO_LEVEL(ioprio) ((ioprio) & IOPRIO_LEVEL_MASK) ++ ++#define IOPRIO_BE_NR IOPRIO_NR_LEVELS + ++/* ++ * Possible values for the "which" argument of the ioprio_get() and ++ * ioprio_set() system calls (see "man ioprio_set"). ++ */ + enum { + IOPRIO_WHO_PROCESS = 1, + IOPRIO_WHO_PGRP, +@@ -44,9 +57,71 @@ enum { + }; + + /* +- * Fallback BE priority level. ++ * Fallback BE class priority level. + */ + #define IOPRIO_NORM 4 + #define IOPRIO_BE_NORM IOPRIO_NORM + ++/* ++ * The 10 bits between the priority class and the priority level are used to ++ * optionally define I/O hints for any combination of I/O priority class and ++ * level. Depending on the kernel configuration, I/O scheduler being used and ++ * the target I/O device being used, hints can influence how I/Os are processed ++ * without affecting the I/O scheduling ordering defined by the I/O priority ++ * class and level. ++ */ ++#define IOPRIO_HINT_SHIFT IOPRIO_LEVEL_NR_BITS ++#define IOPRIO_HINT_NR_BITS 10 ++#define IOPRIO_NR_HINTS (1 << IOPRIO_HINT_NR_BITS) ++#define IOPRIO_HINT_MASK (IOPRIO_NR_HINTS - 1) ++#define IOPRIO_PRIO_HINT(ioprio) \ ++ (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_HINT_MASK) ++ ++/* ++ * I/O hints. ++ */ ++enum { ++ /* No hint */ ++ IOPRIO_HINT_NONE = 0, ++ ++ /* ++ * Device command duration limits: indicate to the device a desired ++ * duration limit for the commands that will be used to process an I/O. ++ * These will currently only be effective for SCSI and ATA devices that ++ * support the command duration limits feature. If this feature is ++ * enabled, then the commands issued to the device to process an I/O with ++ * one of these hints set will have the duration limit index (dld field) ++ * set to the value of the hint. ++ */ ++ IOPRIO_HINT_DEV_DURATION_LIMIT_1 = 1, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_2 = 2, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_3 = 3, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_4 = 4, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_5 = 5, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_6 = 6, ++ IOPRIO_HINT_DEV_DURATION_LIMIT_7 = 7, ++}; ++ ++#define IOPRIO_BAD_VALUE(val, max) ((val) < 0 || (val) >= (max)) ++ ++/* ++ * Return an I/O priority value based on a class, a level and a hint. ++ */ ++static __always_inline __u16 ioprio_value(int prioclass, int priolevel, ++ int priohint) ++{ ++ if (IOPRIO_BAD_VALUE(prioclass, IOPRIO_NR_CLASSES) || ++ IOPRIO_BAD_VALUE(priolevel, IOPRIO_NR_LEVELS) || ++ IOPRIO_BAD_VALUE(priohint, IOPRIO_NR_HINTS)) ++ return IOPRIO_CLASS_INVALID << IOPRIO_CLASS_SHIFT; ++ ++ return (prioclass << IOPRIO_CLASS_SHIFT) | ++ (priohint << IOPRIO_HINT_SHIFT) | priolevel; ++} ++ ++#define IOPRIO_PRIO_VALUE(prioclass, priolevel) \ ++ ioprio_value(prioclass, priolevel, IOPRIO_HINT_NONE) ++#define IOPRIO_PRIO_VALUE_HINT(prioclass, priolevel, priohint) \ ++ ioprio_value(prioclass, priolevel, priohint) ++ + #endif /* _LINUX_IOPRIO_H */ +--- a/x86/usr/include/linux/kfd_ioctl.h ++++ b/x86/usr/include/linux/kfd_ioctl.h +@@ -38,9 +38,11 @@ + * - 1.10 - Add SMI profiler event log + * - 1.11 - Add unified memory for ctx save/restore area + * - 1.12 - Add DMA buf export ioctl ++ * - 1.13 - Add debugger API ++ * - 1.14 - Update kfd_event_data + */ + #define KFD_IOCTL_MAJOR_VERSION 1 +-#define KFD_IOCTL_MINOR_VERSION 12 ++#define KFD_IOCTL_MINOR_VERSION 14 + + struct kfd_ioctl_get_version_args { + __u32 major_version; /* from KFD */ +@@ -110,6 +112,32 @@ struct kfd_ioctl_get_available_memory_ar + __u32 pad; + }; + ++struct kfd_dbg_device_info_entry { ++ __u64 exception_status; ++ __u64 lds_base; ++ __u64 lds_limit; ++ __u64 scratch_base; ++ __u64 scratch_limit; ++ __u64 gpuvm_base; ++ __u64 gpuvm_limit; ++ __u32 gpu_id; ++ __u32 location_id; ++ __u32 vendor_id; ++ __u32 device_id; ++ __u32 revision_id; ++ __u32 subsystem_vendor_id; ++ __u32 subsystem_device_id; ++ __u32 fw_version; ++ __u32 gfx_target_version; ++ __u32 simd_count; ++ __u32 max_waves_per_simd; ++ __u32 array_count; ++ __u32 simd_arrays_per_engine; ++ __u32 num_xcc; ++ __u32 capability; ++ __u32 debug_prop; ++}; ++ + /* For kfd_ioctl_set_memory_policy_args.default_policy and alternate_policy */ + #define KFD_IOC_CACHE_POLICY_COHERENT 0 + #define KFD_IOC_CACHE_POLICY_NONCOHERENT 1 +@@ -293,12 +321,20 @@ struct kfd_hsa_hw_exception_data { + __u32 gpu_id; + }; + ++/* hsa signal event data */ ++struct kfd_hsa_signal_event_data { ++ __u64 last_event_age; /* to and from KFD */ ++}; ++ + /* Event data */ + struct kfd_event_data { + union { ++ /* From KFD */ + struct kfd_hsa_memory_exception_data memory_exception_data; + struct kfd_hsa_hw_exception_data hw_exception_data; +- }; /* From KFD */ ++ /* To and From KFD */ ++ struct kfd_hsa_signal_event_data signal_event_data; ++ }; + __u64 kfd_event_data_ext; /* pointer to an extension structure + for future exception types */ + __u32 event_id; /* to KFD */ +@@ -773,6 +809,640 @@ struct kfd_ioctl_set_xnack_mode_args { + __s32 xnack_enabled; + }; + ++/* Wave launch override modes */ ++enum kfd_dbg_trap_override_mode { ++ KFD_DBG_TRAP_OVERRIDE_OR = 0, ++ KFD_DBG_TRAP_OVERRIDE_REPLACE = 1 ++}; ++ ++/* Wave launch overrides */ ++enum kfd_dbg_trap_mask { ++ KFD_DBG_TRAP_MASK_FP_INVALID = 1, ++ KFD_DBG_TRAP_MASK_FP_INPUT_DENORMAL = 2, ++ KFD_DBG_TRAP_MASK_FP_DIVIDE_BY_ZERO = 4, ++ KFD_DBG_TRAP_MASK_FP_OVERFLOW = 8, ++ KFD_DBG_TRAP_MASK_FP_UNDERFLOW = 16, ++ KFD_DBG_TRAP_MASK_FP_INEXACT = 32, ++ KFD_DBG_TRAP_MASK_INT_DIVIDE_BY_ZERO = 64, ++ KFD_DBG_TRAP_MASK_DBG_ADDRESS_WATCH = 128, ++ KFD_DBG_TRAP_MASK_DBG_MEMORY_VIOLATION = 256, ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_START = (1 << 30), ++ KFD_DBG_TRAP_MASK_TRAP_ON_WAVE_END = (1 << 31) ++}; ++ ++/* Wave launch modes */ ++enum kfd_dbg_trap_wave_launch_mode { ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_NORMAL = 0, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_HALT = 1, ++ KFD_DBG_TRAP_WAVE_LAUNCH_MODE_DEBUG = 3 ++}; ++ ++/* Address watch modes */ ++enum kfd_dbg_trap_address_watch_mode { ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_READ = 0, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_NONREAD = 1, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ATOMIC = 2, ++ KFD_DBG_TRAP_ADDRESS_WATCH_MODE_ALL = 3 ++}; ++ ++/* Additional wave settings */ ++enum kfd_dbg_trap_flags { ++ KFD_DBG_TRAP_FLAG_SINGLE_MEM_OP = 1, ++}; ++ ++/* Trap exceptions */ ++enum kfd_dbg_trap_exception_code { ++ EC_NONE = 0, ++ /* per queue */ ++ EC_QUEUE_WAVE_ABORT = 1, ++ EC_QUEUE_WAVE_TRAP = 2, ++ EC_QUEUE_WAVE_MATH_ERROR = 3, ++ EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION = 4, ++ EC_QUEUE_WAVE_MEMORY_VIOLATION = 5, ++ EC_QUEUE_WAVE_APERTURE_VIOLATION = 6, ++ EC_QUEUE_PACKET_DISPATCH_DIM_INVALID = 16, ++ EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID = 17, ++ EC_QUEUE_PACKET_DISPATCH_CODE_INVALID = 18, ++ EC_QUEUE_PACKET_RESERVED = 19, ++ EC_QUEUE_PACKET_UNSUPPORTED = 20, ++ EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID = 21, ++ EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID = 22, ++ EC_QUEUE_PACKET_VENDOR_UNSUPPORTED = 23, ++ EC_QUEUE_PREEMPTION_ERROR = 30, ++ EC_QUEUE_NEW = 31, ++ /* per device */ ++ EC_DEVICE_QUEUE_DELETE = 32, ++ EC_DEVICE_MEMORY_VIOLATION = 33, ++ EC_DEVICE_RAS_ERROR = 34, ++ EC_DEVICE_FATAL_HALT = 35, ++ EC_DEVICE_NEW = 36, ++ /* per process */ ++ EC_PROCESS_RUNTIME = 48, ++ EC_PROCESS_DEVICE_REMOVE = 49, ++ EC_MAX ++}; ++ ++/* Mask generated by ecode in kfd_dbg_trap_exception_code */ ++#define KFD_EC_MASK(ecode) (1ULL << (ecode - 1)) ++ ++/* Masks for exception code type checks below */ ++#define KFD_EC_MASK_QUEUE (KFD_EC_MASK(EC_QUEUE_WAVE_ABORT) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_TRAP) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MATH_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_ILLEGAL_INSTRUCTION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_WAVE_APERTURE_VIOLATION) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_DIM_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_GROUP_SEGMENT_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_CODE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_RESERVED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_WORK_GROUP_SIZE_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_DISPATCH_REGISTER_INVALID) | \ ++ KFD_EC_MASK(EC_QUEUE_PACKET_VENDOR_UNSUPPORTED) | \ ++ KFD_EC_MASK(EC_QUEUE_PREEMPTION_ERROR) | \ ++ KFD_EC_MASK(EC_QUEUE_NEW)) ++#define KFD_EC_MASK_DEVICE (KFD_EC_MASK(EC_DEVICE_QUEUE_DELETE) | \ ++ KFD_EC_MASK(EC_DEVICE_RAS_ERROR) | \ ++ KFD_EC_MASK(EC_DEVICE_FATAL_HALT) | \ ++ KFD_EC_MASK(EC_DEVICE_MEMORY_VIOLATION) | \ ++ KFD_EC_MASK(EC_DEVICE_NEW)) ++#define KFD_EC_MASK_PROCESS (KFD_EC_MASK(EC_PROCESS_RUNTIME) | \ ++ KFD_EC_MASK(EC_PROCESS_DEVICE_REMOVE)) ++ ++/* Checks for exception code types for KFD search */ ++#define KFD_DBG_EC_TYPE_IS_QUEUE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_QUEUE)) ++#define KFD_DBG_EC_TYPE_IS_DEVICE(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_DEVICE)) ++#define KFD_DBG_EC_TYPE_IS_PROCESS(ecode) \ ++ (!!(KFD_EC_MASK(ecode) & KFD_EC_MASK_PROCESS)) ++ ++ ++/* Runtime enable states */ ++enum kfd_dbg_runtime_state { ++ DEBUG_RUNTIME_STATE_DISABLED = 0, ++ DEBUG_RUNTIME_STATE_ENABLED = 1, ++ DEBUG_RUNTIME_STATE_ENABLED_BUSY = 2, ++ DEBUG_RUNTIME_STATE_ENABLED_ERROR = 3 ++}; ++ ++/* Runtime enable status */ ++struct kfd_runtime_info { ++ __u64 r_debug; ++ __u32 runtime_state; ++ __u32 ttmp_setup; ++}; ++ ++/* Enable modes for runtime enable */ ++#define KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK 1 ++#define KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK 2 ++ ++/** ++ * kfd_ioctl_runtime_enable_args - Arguments for runtime enable ++ * ++ * Coordinates debug exception signalling and debug device enablement with runtime. ++ * ++ * @r_debug - pointer to user struct for sharing information between ROCr and the debuggger ++ * @mode_mask - mask to set mode ++ * KFD_RUNTIME_ENABLE_MODE_ENABLE_MASK - enable runtime for debugging, otherwise disable ++ * KFD_RUNTIME_ENABLE_MODE_TTMP_SAVE_MASK - enable trap temporary setup (ignore on disable) ++ * @capabilities_mask - mask to notify runtime on what KFD supports ++ * ++ * Return - 0 on SUCCESS. ++ * - EBUSY if runtime enable call already pending. ++ * - EEXIST if user queues already active prior to call. ++ * If process is debug enabled, runtime enable will enable debug devices and ++ * wait for debugger process to send runtime exception EC_PROCESS_RUNTIME ++ * to unblock - see kfd_ioctl_dbg_trap_args. ++ * ++ */ ++struct kfd_ioctl_runtime_enable_args { ++ __u64 r_debug; ++ __u32 mode_mask; ++ __u32 capabilities_mask; ++}; ++ ++/* Queue information */ ++struct kfd_queue_snapshot_entry { ++ __u64 exception_status; ++ __u64 ring_base_address; ++ __u64 write_pointer_address; ++ __u64 read_pointer_address; ++ __u64 ctx_save_restore_address; ++ __u32 queue_id; ++ __u32 gpu_id; ++ __u32 ring_size; ++ __u32 queue_type; ++ __u32 ctx_save_restore_area_size; ++ __u32 reserved; ++}; ++ ++/* Queue status return for suspend/resume */ ++#define KFD_DBG_QUEUE_ERROR_BIT 30 ++#define KFD_DBG_QUEUE_INVALID_BIT 31 ++#define KFD_DBG_QUEUE_ERROR_MASK (1 << KFD_DBG_QUEUE_ERROR_BIT) ++#define KFD_DBG_QUEUE_INVALID_MASK (1 << KFD_DBG_QUEUE_INVALID_BIT) ++ ++/* Context save area header information */ ++struct kfd_context_save_area_header { ++ struct { ++ __u32 control_stack_offset; ++ __u32 control_stack_size; ++ __u32 wave_state_offset; ++ __u32 wave_state_size; ++ } wave_state; ++ __u32 debug_offset; ++ __u32 debug_size; ++ __u64 err_payload_addr; ++ __u32 err_event_id; ++ __u32 reserved1; ++}; ++ ++/* ++ * Debug operations ++ * ++ * For specifics on usage and return values, see documentation per operation ++ * below. Otherwise, generic error returns apply: ++ * - ESRCH if the process to debug does not exist. ++ * ++ * - EINVAL (with KFD_IOC_DBG_TRAP_ENABLE exempt) if operation ++ * KFD_IOC_DBG_TRAP_ENABLE has not succeeded prior. ++ * Also returns this error if GPU hardware scheduling is not supported. ++ * ++ * - EPERM (with KFD_IOC_DBG_TRAP_DISABLE exempt) if target process is not ++ * PTRACE_ATTACHED. KFD_IOC_DBG_TRAP_DISABLE is exempt to allow ++ * clean up of debug mode as long as process is debug enabled. ++ * ++ * - EACCES if any DBG_HW_OP (debug hardware operation) is requested when ++ * AMDKFD_IOC_RUNTIME_ENABLE has not succeeded prior. ++ * ++ * - ENODEV if any GPU does not support debugging on a DBG_HW_OP call. ++ * ++ * - Other errors may be returned when a DBG_HW_OP occurs while the GPU ++ * is in a fatal state. ++ * ++ */ ++enum kfd_dbg_trap_operations { ++ KFD_IOC_DBG_TRAP_ENABLE = 0, ++ KFD_IOC_DBG_TRAP_DISABLE = 1, ++ KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT = 2, ++ KFD_IOC_DBG_TRAP_SET_EXCEPTIONS_ENABLED = 3, ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE = 4, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE = 5, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SUSPEND_QUEUES = 6, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_RESUME_QUEUES = 7, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH = 8, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH = 9, /* DBG_HW_OP */ ++ KFD_IOC_DBG_TRAP_SET_FLAGS = 10, ++ KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT = 11, ++ KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO = 12, ++ KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT = 13, ++ KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT = 14 ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_enable_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_ENABLE. ++ * ++ * Enables debug session for target process. Call @op KFD_IOC_DBG_TRAP_DISABLE in ++ * kfd_ioctl_dbg_trap_args to disable debug session. ++ * ++ * @exception_mask (IN) - exceptions to raise to the debugger ++ * @rinfo_ptr (IN) - pointer to runtime info buffer (see kfd_runtime_info) ++ * @rinfo_size (IN/OUT) - size of runtime info buffer in bytes ++ * @dbg_fd (IN) - fd the KFD will nofify the debugger with of raised ++ * exceptions set in exception_mask. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies KFD saved kfd_runtime_info to @rinfo_ptr on enable. ++ * Size of kfd_runtime saved by the KFD returned to @rinfo_size. ++ * - EBADF if KFD cannot get a reference to dbg_fd. ++ * - EFAULT if KFD cannot copy runtime info to rinfo_ptr. ++ * - EINVAL if target process is already debug enabled. ++ * ++ */ ++struct kfd_ioctl_dbg_trap_enable_args { ++ __u64 exception_mask; ++ __u64 rinfo_ptr; ++ __u32 rinfo_size; ++ __u32 dbg_fd; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_send_runtime_event_args ++ * ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SEND_RUNTIME_EVENT. ++ * Raises exceptions to runtime. ++ * ++ * @exception_mask (IN) - exceptions to raise to runtime ++ * @gpu_id (IN) - target device id ++ * @queue_id (IN) - target queue id ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * If exception_mask contains EC_PROCESS_RUNTIME, unblocks pending ++ * AMDKFD_IOC_RUNTIME_ENABLE call - see kfd_ioctl_runtime_enable_args. ++ * All other exceptions are raised to runtime through err_payload_addr. ++ * See kfd_context_save_area_header. ++ */ ++struct kfd_ioctl_dbg_trap_send_runtime_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_exceptions_enabled_args ++ * ++ * Arguments for KFD_IOC_SET_EXCEPTIONS_ENABLED ++ * Set new exceptions to be raised to the debugger. ++ * ++ * @exception_mask (IN) - new exceptions to raise the debugger ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args { ++ __u64 exception_mask; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_override_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_OVERRIDE ++ * Enable HW exceptions to raise trap. ++ * ++ * @override_mode (IN) - see kfd_dbg_trap_override_mode ++ * @enable_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested to be enabled. ++ * OUT is referenced in Return below. ++ * @support_request_mask (IN/OUT) - reference kfd_dbg_trap_mask. ++ * IN is the override modes requested for support check. ++ * OUT is referenced in Return below. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Previous enablement is returned in @enable_mask. ++ * Actual override support is returned in @support_request_mask. ++ * - EINVAL if override mode is not supported. ++ * - EACCES if trap support requested is not actually supported. ++ * i.e. enable_mask (IN) is not a subset of support_request_mask (OUT). ++ * Otherwise it is considered a generic error (see kfd_dbg_trap_operations). ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_override_args { ++ __u32 override_mode; ++ __u32 enable_mask; ++ __u32 support_request_mask; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_wave_launch_mode_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_WAVE_LAUNCH_MODE ++ * Set wave launch mode. ++ * ++ * @mode (IN) - see kfd_dbg_trap_wave_launch_mode ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ */ ++struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args { ++ __u32 launch_mode; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_suspend_queues_ags ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SUSPEND_QUEUES ++ * Suspend queues. ++ * ++ * @exception_mask (IN) - raised exceptions to clear ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to suspend ++ * @num_queues (IN) - number of queues to suspend in @queue_array_ptr ++ * @grace_period (IN) - wave time allowance before preemption ++ * per 1K GPU clock cycle unit ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Destruction of a suspended queue is blocked until the queue is ++ * resumed. This allows the debugger to access queue information and ++ * the its context save area without running into a race condition on ++ * queue destruction. ++ * Automatically copies per queue context save area header information ++ * into the save area base ++ * (see kfd_queue_snapshot_entry and kfd_context_save_area_header). ++ * ++ * Return - Number of queues suspended on SUCCESS. ++ * . KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK masked ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * suspend reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist, is new or ++ * is being destroyed. ++ */ ++struct kfd_ioctl_dbg_trap_suspend_queues_args { ++ __u64 exception_mask; ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 grace_period; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_resume_queues_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_RESUME_QUEUES ++ * Resume queues. ++ * ++ * @queue_array_ptr (IN) - pointer to array of queue ids (u32 per queue id) ++ * to resume ++ * @num_queues (IN) - number of queues to resume in @queue_array_ptr ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - Number of queues resumed on SUCCESS. ++ * KFD_DBG_QUEUE_ERROR_MASK and KFD_DBG_QUEUE_INVALID_MASK mask ++ * for each queue id in @queue_array_ptr array reports unsuccessful ++ * resume reason. ++ * KFD_DBG_QUEUE_ERROR_MASK = HW failure. ++ * KFD_DBG_QUEUE_INVALID_MASK = queue does not exist. ++ */ ++struct kfd_ioctl_dbg_trap_resume_queues_args { ++ __u64 queue_array_ptr; ++ __u32 num_queues; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_NODE_ADDRESS_WATCH ++ * Sets address watch for device. ++ * ++ * @address (IN) - watch address to set ++ * @mode (IN) - see kfd_dbg_trap_address_watch_mode ++ * @mask (IN) - watch address mask ++ * @gpu_id (IN) - target gpu to set watch point ++ * @id (OUT) - watch id allocated ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Allocated watch ID returned to @id. ++ * - ENODEV if gpu_id not found. ++ * - ENOMEM if watch IDs can be allocated ++ */ ++struct kfd_ioctl_dbg_trap_set_node_address_watch_args { ++ __u64 address; ++ __u32 mode; ++ __u32 mask; ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_clear_node_address_watch_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_CLEAR_NODE_ADDRESS_WATCH ++ * Clear address watch for device. ++ * ++ * @gpu_id (IN) - target device to clear watch point ++ * @id (IN) - allocated watch id to clear ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - ENODEV if gpu_id not found. ++ * - EINVAL if watch ID has not been allocated. ++ */ ++struct kfd_ioctl_dbg_trap_clear_node_address_watch_args { ++ __u32 gpu_id; ++ __u32 id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_set_flags_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_SET_FLAGS ++ * Sets flags for wave behaviour. ++ * ++ * @flags (IN/OUT) - IN = flags to enable, OUT = flags previously enabled ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * - EACCESS if any debug device does not allow flag options. ++ */ ++struct kfd_ioctl_dbg_trap_set_flags_args { ++ __u32 flags; ++ __u32 pad; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_debug_event_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_QUERY_DEBUG_EVENT ++ * ++ * Find one or more raised exceptions. This function can return multiple ++ * exceptions from a single queue or a single device with one call. To find ++ * all raised exceptions, this function must be called repeatedly until it ++ * returns -EAGAIN. Returned exceptions can optionally be cleared by ++ * setting the corresponding bit in the @exception_mask input parameter. ++ * However, clearing an exception prevents retrieving further information ++ * about it with KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO. ++ * ++ * @exception_mask (IN/OUT) - exception to clear (IN) and raised (OUT) ++ * @gpu_id (OUT) - gpu id of exceptions raised ++ * @queue_id (OUT) - queue id of exceptions raised ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on raised exception found ++ * Raised exceptions found are returned in @exception mask ++ * with reported source id returned in @gpu_id or @queue_id. ++ * - EAGAIN if no raised exception has been found ++ */ ++struct kfd_ioctl_dbg_trap_query_debug_event_args { ++ __u64 exception_mask; ++ __u32 gpu_id; ++ __u32 queue_id; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_query_exception_info_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_QUERY_EXCEPTION_INFO ++ * Get additional info on raised exception. ++ * ++ * @info_ptr (IN) - pointer to exception info buffer to copy to ++ * @info_size (IN/OUT) - exception info buffer size (bytes) ++ * @source_id (IN) - target gpu or queue id ++ * @exception_code (IN) - target exception ++ * @clear_exception (IN) - clear raised @exception_code exception ++ * (0 = false, 1 = true) ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * If @exception_code is EC_DEVICE_MEMORY_VIOLATION, copy @info_size(OUT) ++ * bytes of memory exception data to @info_ptr. ++ * If @exception_code is EC_PROCESS_RUNTIME, copy saved ++ * kfd_runtime_info to @info_ptr. ++ * Actual required @info_ptr size (bytes) is returned in @info_size. ++ */ ++struct kfd_ioctl_dbg_trap_query_exception_info_args { ++ __u64 info_ptr; ++ __u32 info_size; ++ __u32 source_id; ++ __u32 exception_code; ++ __u32 clear_exception; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_queue_snapshot_args ++ * ++ * Arguments KFD_IOC_DBG_TRAP_GET_QUEUE_SNAPSHOT ++ * Get queue information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - queue snapshot entry buffer (see kfd_queue_snapshot_entry) ++ * @num_queues (IN/OUT) - number of queue snapshot entries ++ * The debugger specifies the size of the array allocated in @num_queues. ++ * KFD returns the number of queues that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_queue_snapshot_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated per ++ * entry. The debugger should use the KFD_IOCTL_MINOR_VERSION to determine, ++ * which fields in struct kfd_queue_snapshot_entry are valid. This allows ++ * growing the ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_queue_snapshot_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_queues(IN) queue snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_queues(IN) > 0. ++ * Otherwise return @num_queues(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_queue_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_queues; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_get_device_snapshot_args ++ * ++ * Arguments for KFD_IOC_DBG_TRAP_GET_DEVICE_SNAPSHOT ++ * Get device information. ++ * ++ * @exception_mask (IN) - exceptions raised to clear ++ * @snapshot_buf_ptr (IN) - pointer to snapshot buffer (see kfd_dbg_device_info_entry) ++ * @num_devices (IN/OUT) - number of debug devices to snapshot ++ * The debugger specifies the size of the array allocated in @num_devices. ++ * KFD returns the number of devices that actually existed. If this is ++ * larger than the size specified by the debugger, KFD will not overflow ++ * the array allocated by the debugger. ++ * ++ * @entry_size (IN/OUT) - size per entry in bytes ++ * The debugger specifies sizeof(struct kfd_dbg_device_info_entry) in ++ * @entry_size. KFD returns the number of bytes actually populated. The ++ * debugger should use KFD_IOCTL_MINOR_VERSION to determine, which fields ++ * in struct kfd_dbg_device_info_entry are valid. This allows growing the ++ * ABI in a backwards compatible manner. ++ * Note that entry_size(IN) should still be used to stride the snapshot buffer in the ++ * event that it's larger than actual kfd_dbg_device_info_entry. ++ * ++ * Generic errors apply (see kfd_dbg_trap_operations). ++ * Return - 0 on SUCCESS. ++ * Copies @num_devices(IN) device snapshot entries of size @entry_size(IN) ++ * into @snapshot_buf_ptr if @num_devices(IN) > 0. ++ * Otherwise return @num_devices(OUT) queue snapshot entries that exist. ++ */ ++struct kfd_ioctl_dbg_trap_device_snapshot_args { ++ __u64 exception_mask; ++ __u64 snapshot_buf_ptr; ++ __u32 num_devices; ++ __u32 entry_size; ++}; ++ ++/** ++ * kfd_ioctl_dbg_trap_args ++ * ++ * Arguments to debug target process. ++ * ++ * @pid - target process to debug ++ * @op - debug operation (see kfd_dbg_trap_operations) ++ * ++ * @op determines which union struct args to use. ++ * Refer to kern docs for each kfd_ioctl_dbg_trap_*_args struct. ++ */ ++struct kfd_ioctl_dbg_trap_args { ++ __u32 pid; ++ __u32 op; ++ ++ union { ++ struct kfd_ioctl_dbg_trap_enable_args enable; ++ struct kfd_ioctl_dbg_trap_send_runtime_event_args send_runtime_event; ++ struct kfd_ioctl_dbg_trap_set_exceptions_enabled_args set_exceptions_enabled; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_override_args launch_override; ++ struct kfd_ioctl_dbg_trap_set_wave_launch_mode_args launch_mode; ++ struct kfd_ioctl_dbg_trap_suspend_queues_args suspend_queues; ++ struct kfd_ioctl_dbg_trap_resume_queues_args resume_queues; ++ struct kfd_ioctl_dbg_trap_set_node_address_watch_args set_node_address_watch; ++ struct kfd_ioctl_dbg_trap_clear_node_address_watch_args clear_node_address_watch; ++ struct kfd_ioctl_dbg_trap_set_flags_args set_flags; ++ struct kfd_ioctl_dbg_trap_query_debug_event_args query_debug_event; ++ struct kfd_ioctl_dbg_trap_query_exception_info_args query_exception_info; ++ struct kfd_ioctl_dbg_trap_queue_snapshot_args queue_snapshot; ++ struct kfd_ioctl_dbg_trap_device_snapshot_args device_snapshot; ++ }; ++}; ++ + #define AMDKFD_IOCTL_BASE 'K' + #define AMDKFD_IO(nr) _IO(AMDKFD_IOCTL_BASE, nr) + #define AMDKFD_IOR(nr, type) _IOR(AMDKFD_IOCTL_BASE, nr, type) +@@ -887,7 +1557,13 @@ struct kfd_ioctl_set_xnack_mode_args { + #define AMDKFD_IOC_EXPORT_DMABUF \ + AMDKFD_IOWR(0x24, struct kfd_ioctl_export_dmabuf_args) + ++#define AMDKFD_IOC_RUNTIME_ENABLE \ ++ AMDKFD_IOWR(0x25, struct kfd_ioctl_runtime_enable_args) ++ ++#define AMDKFD_IOC_DBG_TRAP \ ++ AMDKFD_IOWR(0x26, struct kfd_ioctl_dbg_trap_args) ++ + #define AMDKFD_COMMAND_START 0x01 +-#define AMDKFD_COMMAND_END 0x25 ++#define AMDKFD_COMMAND_END 0x27 + + #endif +--- a/x86/usr/include/linux/kfd_sysfs.h ++++ b/x86/usr/include/linux/kfd_sysfs.h +@@ -43,6 +43,11 @@ + #define HSA_CAP_DOORBELL_TYPE_2_0 0x2 + #define HSA_CAP_AQL_QUEUE_DOUBLE_MAP 0x00004000 + ++#define HSA_CAP_TRAP_DEBUG_SUPPORT 0x00008000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_TRAP_OVERRIDE_SUPPORTED 0x00010000 ++#define HSA_CAP_TRAP_DEBUG_WAVE_LAUNCH_MODE_SUPPORTED 0x00020000 ++#define HSA_CAP_TRAP_DEBUG_PRECISE_MEMORY_OPERATIONS_SUPPORTED 0x00040000 ++ + /* Old buggy user mode depends on this being 0 */ + #define HSA_CAP_RESERVED_WAS_SRAM_EDCSUPPORTED 0x00080000 + +@@ -53,8 +58,18 @@ + #define HSA_CAP_SRAM_EDCSUPPORTED 0x04000000 + #define HSA_CAP_SVMAPI_SUPPORTED 0x08000000 + #define HSA_CAP_FLAGS_COHERENTHOSTACCESS 0x10000000 ++#define HSA_CAP_TRAP_DEBUG_FIRMWARE_SUPPORTED 0x20000000 + #define HSA_CAP_RESERVED 0xe00f8000 + ++/* debug_prop bits in node properties */ ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_MASK 0x0000000f ++#define HSA_DBG_WATCH_ADDR_MASK_LO_BIT_SHIFT 0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_MASK 0x000003f0 ++#define HSA_DBG_WATCH_ADDR_MASK_HI_BIT_SHIFT 4 ++#define HSA_DBG_DISPATCH_INFO_ALWAYS_VALID 0x00000400 ++#define HSA_DBG_WATCHPOINTS_EXCLUSIVE 0x00000800 ++#define HSA_DBG_RESERVED 0xfffffffffffff000ull ++ + /* Heap types in memory properties */ + #define HSA_MEM_HEAP_TYPE_SYSTEM 0 + #define HSA_MEM_HEAP_TYPE_FB_PUBLIC 1 +--- a/x86/usr/include/linux/netdev.h ++++ b/x86/usr/include/linux/netdev.h +@@ -11,7 +11,7 @@ + + /** + * enum netdev_xdp_act +- * @NETDEV_XDP_ACT_BASIC: XDP feautues set supported by all drivers ++ * @NETDEV_XDP_ACT_BASIC: XDP features set supported by all drivers + * (XDP_ABORTED, XDP_DROP, XDP_PASS, XDP_TX) + * @NETDEV_XDP_ACT_REDIRECT: The netdev supports XDP_REDIRECT + * @NETDEV_XDP_ACT_NDO_XMIT: This feature informs if netdev implements +@@ -34,28 +34,125 @@ enum netdev_xdp_act { + NETDEV_XDP_ACT_RX_SG = 32, + NETDEV_XDP_ACT_NDO_XMIT_SG = 64, + ++ /* private: */ + NETDEV_XDP_ACT_MASK = 127, + }; + ++/** ++ * enum netdev_xdp_rx_metadata ++ * @NETDEV_XDP_RX_METADATA_TIMESTAMP: Device is capable of exposing receive HW ++ * timestamp via bpf_xdp_metadata_rx_timestamp(). ++ * @NETDEV_XDP_RX_METADATA_HASH: Device is capable of exposing receive packet ++ * hash via bpf_xdp_metadata_rx_hash(). ++ * @NETDEV_XDP_RX_METADATA_VLAN_TAG: Device is capable of exposing receive ++ * packet VLAN tag via bpf_xdp_metadata_rx_vlan_tag(). ++ */ ++enum netdev_xdp_rx_metadata { ++ NETDEV_XDP_RX_METADATA_TIMESTAMP = 1, ++ NETDEV_XDP_RX_METADATA_HASH = 2, ++ NETDEV_XDP_RX_METADATA_VLAN_TAG = 4, ++}; ++ ++/** ++ * enum netdev_xsk_flags ++ * @NETDEV_XSK_FLAGS_TX_TIMESTAMP: HW timestamping egress packets is supported ++ * by the driver. ++ * @NETDEV_XSK_FLAGS_TX_CHECKSUM: L3 checksum HW offload is supported by the ++ * driver. ++ */ ++enum netdev_xsk_flags { ++ NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1, ++ NETDEV_XSK_FLAGS_TX_CHECKSUM = 2, ++ ++ /* private: */ ++ NETDEV_XSK_FLAGS_MASK = 3, ++}; ++ ++enum netdev_queue_type { ++ NETDEV_QUEUE_TYPE_RX, ++ NETDEV_QUEUE_TYPE_TX, ++}; ++ + enum { + NETDEV_A_DEV_IFINDEX = 1, + NETDEV_A_DEV_PAD, + NETDEV_A_DEV_XDP_FEATURES, ++ NETDEV_A_DEV_XDP_ZC_MAX_SEGS, ++ NETDEV_A_DEV_XDP_RX_METADATA_FEATURES, ++ NETDEV_A_DEV_XSK_FEATURES, + + __NETDEV_A_DEV_MAX, + NETDEV_A_DEV_MAX = (__NETDEV_A_DEV_MAX - 1) + }; + + enum { ++ NETDEV_A_PAGE_POOL_ID = 1, ++ NETDEV_A_PAGE_POOL_IFINDEX, ++ NETDEV_A_PAGE_POOL_NAPI_ID, ++ NETDEV_A_PAGE_POOL_INFLIGHT, ++ NETDEV_A_PAGE_POOL_INFLIGHT_MEM, ++ NETDEV_A_PAGE_POOL_DETACH_TIME, ++ ++ __NETDEV_A_PAGE_POOL_MAX, ++ NETDEV_A_PAGE_POOL_MAX = (__NETDEV_A_PAGE_POOL_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_PAGE_POOL_STATS_INFO = 1, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_FAST = 8, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_SLOW_HIGH_ORDER, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_EMPTY, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_REFILL, ++ NETDEV_A_PAGE_POOL_STATS_ALLOC_WAIVE, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHED, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_CACHE_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RING_FULL, ++ NETDEV_A_PAGE_POOL_STATS_RECYCLE_RELEASED_REFCNT, ++ ++ __NETDEV_A_PAGE_POOL_STATS_MAX, ++ NETDEV_A_PAGE_POOL_STATS_MAX = (__NETDEV_A_PAGE_POOL_STATS_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_NAPI_IFINDEX = 1, ++ NETDEV_A_NAPI_ID, ++ NETDEV_A_NAPI_IRQ, ++ NETDEV_A_NAPI_PID, ++ ++ __NETDEV_A_NAPI_MAX, ++ NETDEV_A_NAPI_MAX = (__NETDEV_A_NAPI_MAX - 1) ++}; ++ ++enum { ++ NETDEV_A_QUEUE_ID = 1, ++ NETDEV_A_QUEUE_IFINDEX, ++ NETDEV_A_QUEUE_TYPE, ++ NETDEV_A_QUEUE_NAPI_ID, ++ ++ __NETDEV_A_QUEUE_MAX, ++ NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1) ++}; ++ ++enum { + NETDEV_CMD_DEV_GET = 1, + NETDEV_CMD_DEV_ADD_NTF, + NETDEV_CMD_DEV_DEL_NTF, + NETDEV_CMD_DEV_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_GET, ++ NETDEV_CMD_PAGE_POOL_ADD_NTF, ++ NETDEV_CMD_PAGE_POOL_DEL_NTF, ++ NETDEV_CMD_PAGE_POOL_CHANGE_NTF, ++ NETDEV_CMD_PAGE_POOL_STATS_GET, ++ NETDEV_CMD_QUEUE_GET, ++ NETDEV_CMD_NAPI_GET, + + __NETDEV_CMD_MAX, + NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1) + }; + + #define NETDEV_MCGRP_MGMT "mgmt" ++#define NETDEV_MCGRP_PAGE_POOL "page-pool" + + #endif /* _LINUX_NETDEV_H */ +--- a/x86/usr/include/linux/netlink.h ++++ b/x86/usr/include/linux/netlink.h +@@ -294,6 +294,8 @@ struct nla_bitfield32 { + * entry has attributes again, the policy for those inner ones + * and the corresponding maxtype may be specified. + * @NL_ATTR_TYPE_BITFIELD32: &struct nla_bitfield32 attribute ++ * @NL_ATTR_TYPE_SINT: 32-bit or 64-bit signed attribute, aligned to 4B ++ * @NL_ATTR_TYPE_UINT: 32-bit or 64-bit unsigned attribute, aligned to 4B + */ + enum netlink_attribute_type { + NL_ATTR_TYPE_INVALID, +@@ -318,6 +320,9 @@ enum netlink_attribute_type { + NL_ATTR_TYPE_NESTED_ARRAY, + + NL_ATTR_TYPE_BITFIELD32, ++ ++ NL_ATTR_TYPE_SINT, ++ NL_ATTR_TYPE_UINT, + }; + + /** +--- a/x86/usr/include/linux/nl80211.h ++++ b/x86/usr/include/linux/nl80211.h +@@ -11,7 +11,7 @@ + * Copyright 2008 Jouni Malinen + * Copyright 2008 Colin McCabe + * Copyright 2015-2017 Intel Deutschland GmbH +- * Copyright (C) 2018-2022 Intel Corporation ++ * Copyright (C) 2018-2023 Intel Corporation + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above +@@ -1309,6 +1309,11 @@ + * The number of peers that HW timestamping can be enabled for concurrently + * is indicated by %NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS. + * ++ * @NL80211_CMD_LINKS_REMOVED: Notify userspace about the removal of STA MLD ++ * setup links due to AP MLD removing the corresponding affiliated APs with ++ * Multi-Link reconfiguration. %NL80211_ATTR_MLO_LINKS is used to provide ++ * information about the removed STA MLD setup links. ++ * + * @NL80211_CMD_MAX: highest used command number + * @__NL80211_CMD_AFTER_LAST: internal use + */ +@@ -1562,6 +1567,8 @@ enum nl80211_commands { + + NL80211_CMD_SET_HW_TIMESTAMP, + ++ NL80211_CMD_LINKS_REMOVED, ++ + /* add new commands above here */ + + /* used to define NL80211_CMD_MAX below */ +@@ -2805,6 +2812,9 @@ enum nl80211_commands { + * index. If the userspace includes more RNR elements than number of + * MBSSID elements then these will be added in every EMA beacon. + * ++ * @NL80211_ATTR_MLO_LINK_DISABLED: Flag attribute indicating that the link is ++ * disabled. ++ * + * @NUM_NL80211_ATTR: total number of nl80211_attrs available + * @NL80211_ATTR_MAX: highest attribute number currently defined + * @__NL80211_ATTR_AFTER_LAST: internal use +@@ -3341,6 +3351,8 @@ enum nl80211_attrs { + + NL80211_ATTR_EMA_RNR_ELEMS, + ++ NL80211_ATTR_MLO_LINK_DISABLED, ++ + /* add attributes here, update the policy in nl80211.c */ + + __NL80211_ATTR_AFTER_LAST, +@@ -3667,6 +3679,13 @@ enum nl80211_eht_ru_alloc { + * (u8, see &enum nl80211_eht_gi) + * @NL80211_RATE_INFO_EHT_RU_ALLOC: EHT RU allocation, if not present then + * non-OFDMA was used (u8, see &enum nl80211_eht_ru_alloc) ++ * @NL80211_RATE_INFO_S1G_MCS: S1G MCS index (u8, 0-10) ++ * @NL80211_RATE_INFO_S1G_NSS: S1G NSS value (u8, 1-4) ++ * @NL80211_RATE_INFO_1_MHZ_WIDTH: 1 MHz S1G rate ++ * @NL80211_RATE_INFO_2_MHZ_WIDTH: 2 MHz S1G rate ++ * @NL80211_RATE_INFO_4_MHZ_WIDTH: 4 MHz S1G rate ++ * @NL80211_RATE_INFO_8_MHZ_WIDTH: 8 MHz S1G rate ++ * @NL80211_RATE_INFO_16_MHZ_WIDTH: 16 MHz S1G rate + * @__NL80211_RATE_INFO_AFTER_LAST: internal use + */ + enum nl80211_rate_info { +@@ -3693,6 +3712,13 @@ enum nl80211_rate_info { + NL80211_RATE_INFO_EHT_NSS, + NL80211_RATE_INFO_EHT_GI, + NL80211_RATE_INFO_EHT_RU_ALLOC, ++ NL80211_RATE_INFO_S1G_MCS, ++ NL80211_RATE_INFO_S1G_NSS, ++ NL80211_RATE_INFO_1_MHZ_WIDTH, ++ NL80211_RATE_INFO_2_MHZ_WIDTH, ++ NL80211_RATE_INFO_4_MHZ_WIDTH, ++ NL80211_RATE_INFO_8_MHZ_WIDTH, ++ NL80211_RATE_INFO_16_MHZ_WIDTH, + + /* keep last */ + __NL80211_RATE_INFO_AFTER_LAST, +@@ -4424,6 +4450,7 @@ enum nl80211_sched_scan_match_attr { + * @NL80211_RRF_NO_160MHZ: 160MHz operation not allowed + * @NL80211_RRF_NO_HE: HE operation not allowed + * @NL80211_RRF_NO_320MHZ: 320MHz operation not allowed ++ * @NL80211_RRF_NO_EHT: EHT operation not allowed + */ + enum nl80211_reg_rule_flags { + NL80211_RRF_NO_OFDM = 1<<0, +@@ -4443,6 +4470,7 @@ enum nl80211_reg_rule_flags { + NL80211_RRF_NO_160MHZ = 1<<16, + NL80211_RRF_NO_HE = 1<<17, + NL80211_RRF_NO_320MHZ = 1<<18, ++ NL80211_RRF_NO_EHT = 1<<19, + }; + + #define NL80211_RRF_PASSIVE_SCAN NL80211_RRF_NO_IR +--- a/x86/usr/include/linux/perf_event.h ++++ b/x86/usr/include/linux/perf_event.h +@@ -204,6 +204,8 @@ enum perf_branch_sample_type_shift { + + PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT = 18, /* save privilege mode */ + ++ PERF_SAMPLE_BRANCH_COUNTERS_SHIFT = 19, /* save occurrences of events on a branch */ ++ + PERF_SAMPLE_BRANCH_MAX_SHIFT /* non-ABI */ + }; + +@@ -235,6 +237,8 @@ enum perf_branch_sample_type { + + PERF_SAMPLE_BRANCH_PRIV_SAVE = 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT, + ++ PERF_SAMPLE_BRANCH_COUNTERS = 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT, ++ + PERF_SAMPLE_BRANCH_MAX = 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT, + }; + +@@ -982,6 +986,12 @@ enum perf_event_type { + * { u64 nr; + * { u64 hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX + * { u64 from, to, flags } lbr[nr]; ++ * # ++ * # The format of the counters is decided by the ++ * # "branch_counter_nr" and "branch_counter_width", ++ * # which are defined in the ABI. ++ * # ++ * { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS + * } && PERF_SAMPLE_BRANCH_STACK + * + * { u64 abi; # enum perf_sample_regs_abi +@@ -1339,7 +1349,8 @@ union perf_mem_data_src { + #define PERF_MEM_LVLNUM_L2 0x02 /* L2 */ + #define PERF_MEM_LVLNUM_L3 0x03 /* L3 */ + #define PERF_MEM_LVLNUM_L4 0x04 /* L4 */ +-/* 5-0x8 available */ ++/* 5-0x7 available */ ++#define PERF_MEM_LVLNUM_UNC 0x08 /* Uncached */ + #define PERF_MEM_LVLNUM_CXL 0x09 /* CXL */ + #define PERF_MEM_LVLNUM_IO 0x0a /* I/O */ + #define PERF_MEM_LVLNUM_ANY_CACHE 0x0b /* Any cache */ +@@ -1426,6 +1437,9 @@ struct perf_branch_entry { + reserved:31; + }; + ++/* Size of used info bits in struct perf_branch_entry */ ++#define PERF_BRANCH_ENTRY_INFO_BITS_MAX 33 ++ + union perf_sample_weight { + __u64 full; + #if defined(__LITTLE_ENDIAN_BITFIELD) +--- a/x86/usr/include/linux/pkt_sched.h ++++ b/x86/usr/include/linux/pkt_sched.h +@@ -1260,6 +1260,16 @@ enum { + }; + + enum { ++ TCA_TAPRIO_OFFLOAD_STATS_PAD = 1, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_WINDOW_DROPS, /* u64 */ ++ TCA_TAPRIO_OFFLOAD_STATS_TX_OVERRUNS, /* u64 */ ++ ++ /* add new constants above here */ ++ __TCA_TAPRIO_OFFLOAD_STATS_CNT, ++ TCA_TAPRIO_OFFLOAD_STATS_MAX = (__TCA_TAPRIO_OFFLOAD_STATS_CNT - 1) ++}; ++ ++enum { + TCA_TAPRIO_ATTR_UNSPEC, + TCA_TAPRIO_ATTR_PRIOMAP, /* struct tc_mqprio_qopt */ + TCA_TAPRIO_ATTR_SCHED_ENTRY_LIST, /* nested of entry */ +--- a/x86/usr/include/linux/pktcdvd.h ++++ b/x86/usr/include/linux/pktcdvd.h +@@ -16,6 +16,7 @@ + #include + + /* ++ * UNUSED: + * 1 for normal debug messages, 2 is very verbose. 0 to turn it off. + */ + #define PACKET_DEBUG 1 +--- a/x86/usr/include/linux/prctl.h ++++ b/x86/usr/include/linux/prctl.h +@@ -283,7 +283,7 @@ struct prctl_mm_map { + + /* Memory deny write / execute */ + #define PR_SET_MDWE 65 +-# define PR_MDWE_REFUSE_EXEC_GAIN 1 ++# define PR_MDWE_REFUSE_EXEC_GAIN (1UL << 0) + + #define PR_GET_MDWE 66 + +--- a/x86/usr/include/linux/psp-sev.h ++++ b/x86/usr/include/linux/psp-sev.h +@@ -68,6 +68,7 @@ typedef enum { + SEV_RET_INVALID_PARAM, + SEV_RET_RESOURCE_LIMIT, + SEV_RET_SECURE_DATA_INVALID, ++ SEV_RET_INVALID_KEY = 0x27, + SEV_RET_MAX, + } sev_ret_code; + +--- a/x86/usr/include/linux/ptp_clock.h ++++ b/x86/usr/include/linux/ptp_clock.h +@@ -95,7 +95,8 @@ struct ptp_clock_caps { + int cross_timestamping; + /* Whether the clock supports adjust phase */ + int adjust_phase; +- int rsv[12]; /* Reserved for future use. */ ++ int max_phase_adj; /* Maximum phase adjustment in nanoseconds. */ ++ int rsv[11]; /* Reserved for future use. */ + }; + + struct ptp_extts_request { +--- a/x86/usr/include/linux/raid/md_p.h ++++ b/x86/usr/include/linux/raid/md_p.h +@@ -89,6 +89,7 @@ + * devices available - and don't try to + * correct read errors. + */ ++#define MD_DISK_TIMEOUT 11 /* disk is faulty due to timeout */ + + #define MD_DISK_WRITEMOSTLY 9 /* disk is "write-mostly" is RAID1 config. + * read requests will only be sent here in +@@ -99,6 +100,7 @@ + #define MD_DISK_ROLE_SPARE 0xffff + #define MD_DISK_ROLE_FAULTY 0xfffe + #define MD_DISK_ROLE_JOURNAL 0xfffd ++#define MD_DISK_ROLE_TIMEOUT 0xfff0 /* SUSE-only timed-out */ + #define MD_DISK_ROLE_MAX 0xff00 /* max value of regular disk role */ + + typedef struct mdp_device_descriptor_s { +--- a/x86/usr/include/linux/sed-opal.h ++++ b/x86/usr/include/linux/sed-opal.h +@@ -49,13 +49,23 @@ enum opal_lock_flags { + OPAL_SAVE_FOR_LOCK = 0x01, + }; + ++enum opal_key_type { ++ OPAL_INCLUDED = 0, /* key[] is the key */ ++ OPAL_KEYRING, /* key is in keyring */ ++}; ++ + struct opal_key { + __u8 lr; + __u8 key_len; +- __u8 __align[6]; ++ __u8 key_type; ++ __u8 __align[5]; + __u8 key[OPAL_KEY_MAX]; + }; + ++enum opal_revert_lsp_opts { ++ OPAL_PRESERVE = 0x01, ++}; ++ + struct opal_lr_act { + struct opal_key key; + __u32 sum; +@@ -173,6 +183,17 @@ struct opal_geometry { + __u8 __align[3]; + }; + ++struct opal_discovery { ++ __u64 data; ++ __u64 size; ++}; ++ ++struct opal_revert_lsp { ++ struct opal_key key; ++ __u32 options; ++ __u32 __pad; ++}; ++ + #define IOC_OPAL_SAVE _IOW('p', 220, struct opal_lock_unlock) + #define IOC_OPAL_LOCK_UNLOCK _IOW('p', 221, struct opal_lock_unlock) + #define IOC_OPAL_TAKE_OWNERSHIP _IOW('p', 222, struct opal_key) +@@ -192,5 +213,7 @@ struct opal_geometry { + #define IOC_OPAL_GET_STATUS _IOR('p', 236, struct opal_status) + #define IOC_OPAL_GET_LR_STATUS _IOW('p', 237, struct opal_lr_status) + #define IOC_OPAL_GET_GEOMETRY _IOR('p', 238, struct opal_geometry) ++#define IOC_OPAL_DISCOVERY _IOW('p', 239, struct opal_discovery) ++#define IOC_OPAL_REVERT_LSP _IOW('p', 240, struct opal_revert_lsp) + + #endif /* _SED_OPAL_H */ +--- a/x86/usr/include/linux/sev-guest.h ++++ b/x86/usr/include/linux/sev-guest.h +@@ -14,9 +14,11 @@ + + #include + ++#define SNP_REPORT_USER_DATA_SIZE 64 ++ + struct snp_report_req { + /* user data that should be included in the report */ +- __u8 user_data[64]; ++ __u8 user_data[SNP_REPORT_USER_DATA_SIZE]; + + /* The vmpl level to be included in the report */ + __u32 vmpl; +--- a/x86/usr/include/linux/stddef.h ++++ b/x86/usr/include/linux/stddef.h +@@ -27,8 +27,13 @@ + union { \ + struct { MEMBERS } ATTRS; \ + struct TAG { MEMBERS } ATTRS NAME; \ +- } ++ } ATTRS + ++#ifdef __cplusplus ++/* sizeof(struct{}) is 1 in C++, not 0, can't use C version of the macro. */ ++#define __DECLARE_FLEX_ARRAY(T, member) \ ++ T member[0] ++#else + /** + * __DECLARE_FLEX_ARRAY() - Declare a flexible array usable in a union + * +@@ -45,3 +50,9 @@ + TYPE NAME[]; \ + } + #endif ++ ++#ifndef __counted_by ++#define __counted_by(m) ++#endif ++ ++#endif /* _LINUX_STDDEF_H */ +--- a/x86/usr/include/linux/sync_file.h ++++ b/x86/usr/include/linux/sync_file.h +@@ -56,7 +56,7 @@ struct sync_fence_info { + * @name: name of fence + * @status: status of fence. 1: signaled 0:active <0:error + * @flags: sync_file_info flags +- * @num_fences number of fences in the sync_file ++ * @num_fences: number of fences in the sync_file + * @pad: padding for 64-bit alignment, should always be zero + * @sync_fence_info: pointer to array of struct &sync_fence_info with all + * fences in the sync_file +--- a/x86/usr/include/linux/ublk_cmd.h ++++ b/x86/usr/include/linux/ublk_cmd.h +@@ -47,6 +47,14 @@ + _IOWR('u', UBLK_CMD_END_USER_RECOVERY, struct ublksrv_ctrl_cmd) + #define UBLK_U_CMD_GET_DEV_INFO2 \ + _IOR('u', UBLK_CMD_GET_DEV_INFO2, struct ublksrv_ctrl_cmd) ++#define UBLK_U_CMD_GET_FEATURES \ ++ _IOR('u', 0x13, struct ublksrv_ctrl_cmd) ++ ++/* ++ * 64bits are enough now, and it should be easy to extend in case of ++ * running out of feature flags ++ */ ++#define UBLK_FEATURES_LEN 8 + + /* + * IO commands, issued by ublk server, and handled by ublk driver. +@@ -93,9 +101,29 @@ + #define UBLKSRV_CMD_BUF_OFFSET 0 + #define UBLKSRV_IO_BUF_OFFSET 0x80000000 + +-/* tag bit is 12bit, so at most 4096 IOs for each queue */ ++/* tag bit is 16bit, so far limit at most 4096 IOs for each queue */ + #define UBLK_MAX_QUEUE_DEPTH 4096 + ++/* single IO buffer max size is 32MB */ ++#define UBLK_IO_BUF_OFF 0 ++#define UBLK_IO_BUF_BITS 25 ++#define UBLK_IO_BUF_BITS_MASK ((1ULL << UBLK_IO_BUF_BITS) - 1) ++ ++/* so at most 64K IOs for each queue */ ++#define UBLK_TAG_OFF UBLK_IO_BUF_BITS ++#define UBLK_TAG_BITS 16 ++#define UBLK_TAG_BITS_MASK ((1ULL << UBLK_TAG_BITS) - 1) ++ ++/* max 4096 queues */ ++#define UBLK_QID_OFF (UBLK_TAG_OFF + UBLK_TAG_BITS) ++#define UBLK_QID_BITS 12 ++#define UBLK_QID_BITS_MASK ((1ULL << UBLK_QID_BITS) - 1) ++ ++#define UBLK_MAX_NR_QUEUES (1U << UBLK_QID_BITS) ++ ++#define UBLKSRV_IO_BUF_TOTAL_BITS (UBLK_QID_OFF + UBLK_QID_BITS) ++#define UBLKSRV_IO_BUF_TOTAL_SIZE (1ULL << UBLKSRV_IO_BUF_TOTAL_BITS) ++ + /* + * zero copy requires 4k block size, and can remap ublk driver's io + * request into ublksrv's vm space +@@ -145,6 +173,15 @@ + /* use ioctl encoding for uring command */ + #define UBLK_F_CMD_IOCTL_ENCODE (1UL << 6) + ++/* Copy between request and user buffer by pread()/pwrite() */ ++#define UBLK_F_USER_COPY (1UL << 7) ++ ++/* ++ * User space sets this flag when setting up the device to request zoned storage support. Kernel may ++ * deny the request by returning an error. ++ */ ++#define UBLK_F_ZONED (1ULL << 8) ++ + /* device state */ + #define UBLK_S_DEV_DEAD 0 + #define UBLK_S_DEV_LIVE 1 +@@ -201,9 +238,27 @@ struct ublksrv_ctrl_dev_info { + #define UBLK_IO_OP_READ 0 + #define UBLK_IO_OP_WRITE 1 + #define UBLK_IO_OP_FLUSH 2 +-#define UBLK_IO_OP_DISCARD 3 +-#define UBLK_IO_OP_WRITE_SAME 4 +-#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_DISCARD 3 ++#define UBLK_IO_OP_WRITE_SAME 4 ++#define UBLK_IO_OP_WRITE_ZEROES 5 ++#define UBLK_IO_OP_ZONE_OPEN 10 ++#define UBLK_IO_OP_ZONE_CLOSE 11 ++#define UBLK_IO_OP_ZONE_FINISH 12 ++#define UBLK_IO_OP_ZONE_APPEND 13 ++#define UBLK_IO_OP_ZONE_RESET_ALL 14 ++#define UBLK_IO_OP_ZONE_RESET 15 ++/* ++ * Construct a zone report. The report request is carried in `struct ++ * ublksrv_io_desc`. The `start_sector` field must be the first sector of a zone ++ * and shall indicate the first zone of the report. The `nr_zones` shall ++ * indicate how many zones should be reported at most. The report shall be ++ * delivered as a `struct blk_zone` array. To report fewer zones than requested, ++ * zero the last entry of the returned array. ++ * ++ * Related definitions(blk_zone, blk_zone_cond, blk_zone_type, ...) in ++ * include/uapi/linux/blkzoned.h are part of ublk UAPI. ++ */ ++#define UBLK_IO_OP_REPORT_ZONES 18 + + #define UBLK_IO_F_FAILFAST_DEV (1U << 8) + #define UBLK_IO_F_FAILFAST_TRANSPORT (1U << 9) +@@ -224,7 +279,10 @@ struct ublksrv_io_desc { + /* op: bit 0-7, flags: bit 8-31 */ + __u32 op_flags; + +- __u32 nr_sectors; ++ union { ++ __u32 nr_sectors; ++ __u32 nr_zones; /* for UBLK_IO_OP_REPORT_ZONES */ ++ }; + + /* start sector for this io */ + __u64 start_sector; +@@ -253,11 +311,21 @@ struct ublksrv_io_cmd { + /* io result, it is valid for COMMIT* command only */ + __s32 result; + +- /* +- * userspace buffer address in ublksrv daemon process, valid for +- * FETCH* command only +- */ +- __u64 addr; ++ union { ++ /* ++ * userspace buffer address in ublksrv daemon process, valid for ++ * FETCH* command only ++ * ++ * `addr` should not be used when UBLK_F_USER_COPY is enabled, ++ * because userspace handles data copy by pread()/pwrite() over ++ * /dev/ublkcN. But in case of UBLK_F_ZONED, this union is ++ * re-used to pass back the allocated LBA for ++ * UBLK_IO_OP_ZONE_APPEND which actually depends on ++ * UBLK_F_USER_COPY ++ */ ++ __u64 addr; ++ __u64 zone_append_lba; ++ }; + }; + + struct ublk_param_basic { +@@ -300,6 +368,13 @@ struct ublk_param_devt { + __u32 disk_minor; + }; + ++struct ublk_param_zoned { ++ __u32 max_open_zones; ++ __u32 max_active_zones; ++ __u32 max_zone_append_sectors; ++ __u8 reserved[20]; ++}; ++ + struct ublk_params { + /* + * Total length of parameters, userspace has to set 'len' for both +@@ -311,11 +386,13 @@ struct ublk_params { + #define UBLK_PARAM_TYPE_BASIC (1 << 0) + #define UBLK_PARAM_TYPE_DISCARD (1 << 1) + #define UBLK_PARAM_TYPE_DEVT (1 << 2) ++#define UBLK_PARAM_TYPE_ZONED (1 << 3) + __u32 types; /* types of parameter included */ + + struct ublk_param_basic basic; + struct ublk_param_discard discard; + struct ublk_param_devt devt; ++ struct ublk_param_zoned zoned; + }; + + #endif +--- a/x86/usr/include/linux/v4l2-controls.h ++++ b/x86/usr/include/linux/v4l2-controls.h +@@ -201,6 +201,12 @@ enum v4l2_colorfx { + */ + #define V4L2_CID_USER_ASPEED_BASE (V4L2_CID_USER_BASE + 0x11a0) + ++/* ++ * The base for Nuvoton NPCM driver controls. ++ * We reserve 16 controls for this driver. ++ */ ++#define V4L2_CID_USER_NPCM_BASE (V4L2_CID_USER_BASE + 0x11b0) ++ + /* MPEG-class control IDs */ + /* The MPEG controls are applicable to all codec controls + * and the 'MPEG' part of the define is historical */ +@@ -800,6 +806,88 @@ enum v4l2_mpeg_video_frame_skip_mode { + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY (V4L2_CID_CODEC_BASE + 653) + #define V4L2_CID_MPEG_VIDEO_DEC_DISPLAY_DELAY_ENABLE (V4L2_CID_CODEC_BASE + 654) + ++#define V4L2_CID_MPEG_VIDEO_AV1_PROFILE (V4L2_CID_CODEC_BASE + 655) ++/** ++ * enum v4l2_mpeg_video_av1_profile - AV1 profiles ++ * ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN: compliant decoders must be able to decode ++ * streams with seq_profile equal to 0. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH: compliant decoders must be able to decode ++ * streams with seq_profile equal less than or equal to 1. ++ * @V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL: compliant decoders must be able to ++ * decode streams with seq_profile less than or equal to 2. ++ * ++ * Conveys the highest profile a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_profile { ++ V4L2_MPEG_VIDEO_AV1_PROFILE_MAIN = 0, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_HIGH = 1, ++ V4L2_MPEG_VIDEO_AV1_PROFILE_PROFESSIONAL = 2, ++}; ++ ++#define V4L2_CID_MPEG_VIDEO_AV1_LEVEL (V4L2_CID_CODEC_BASE + 656) ++/** ++ * enum v4l2_mpeg_video_av1_level - AV1 levels ++ * ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_0: Level 2.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_1: Level 2.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_2: Level 2.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_2_3: Level 2.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_0: Level 3.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_1: Level 3.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_2: Level 3.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_3_3: Level 3.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_0: Level 4.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_1: Level 4.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_2: Level 4.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_4_3: Level 4.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_0: Level 5.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_1: Level 5.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_2: Level 5.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_5_3: Level 5.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_0: Level 6.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_1: Level 6.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_2: Level 6.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_6_3: Level 6.3. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_0: Level 7.0. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_1: Level 7.1. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_2: Level 7.2. ++ * @V4L2_MPEG_VIDEO_AV1_LEVEL_7_3: Level 7.3. ++ * ++ * Conveys the highest level a decoder can work with. ++ */ ++enum v4l2_mpeg_video_av1_level { ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_0 = 0, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_1 = 1, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_2 = 2, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_2_3 = 3, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_0 = 4, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_1 = 5, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_2 = 6, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_3_3 = 7, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_0 = 8, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_1 = 9, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_2 = 10, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_4_3 = 11, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_0 = 12, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_1 = 13, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_2 = 14, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_5_3 = 15, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_0 = 16, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_1 = 17, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_2 = 18, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_6_3 = 19, ++ ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_0 = 20, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_1 = 21, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_2 = 22, ++ V4L2_MPEG_VIDEO_AV1_LEVEL_7_3 = 23 ++}; ++ + /* MPEG-class control IDs specific to the CX2341x driver as defined by V4L2 */ + #define V4L2_CID_CODEC_CX2341X_BASE (V4L2_CTRL_CLASS_CODEC | 0x1000) + #define V4L2_CID_MPEG_CX2341X_VIDEO_SPATIAL_FILTER_MODE (V4L2_CID_CODEC_CX2341X_BASE+0) +@@ -2381,6 +2469,9 @@ struct v4l2_ctrl_hevc_slice_params { + * @poc_st_curr_after: provides the index of the short term after references + * in DPB array + * @poc_lt_curr: provides the index of the long term references in DPB array ++ * @num_delta_pocs_of_ref_rps_idx: same as the derived value NumDeltaPocs[RefRpsIdx], ++ * can be used to parse the RPS data in slice headers ++ * instead of skipping it with @short_term_ref_pic_set_size. + * @reserved: padding field. Should be zeroed by applications. + * @dpb: the decoded picture buffer, for meta-data about reference frames + * @flags: see V4L2_HEVC_DECODE_PARAM_FLAG_{} +@@ -2396,7 +2487,8 @@ struct v4l2_ctrl_hevc_decode_params { + __u8 poc_st_curr_before[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_st_curr_after[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u8 poc_lt_curr[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; +- __u8 reserved[4]; ++ __u8 num_delta_pocs_of_ref_rps_idx; ++ __u8 reserved[3]; + struct v4l2_hevc_dpb_entry dpb[V4L2_HEVC_DPB_ENTRIES_NUM_MAX]; + __u64 flags; + }; +@@ -2750,6 +2842,645 @@ struct v4l2_ctrl_vp9_compressed_hdr { + struct v4l2_vp9_mv_probs mv; + }; + ++/* Stateless AV1 controls */ ++ ++#define V4L2_AV1_TOTAL_REFS_PER_FRAME 8 ++#define V4L2_AV1_CDEF_MAX 8 ++#define V4L2_AV1_NUM_PLANES_MAX 3 /* 1 if monochrome, 3 otherwise */ ++#define V4L2_AV1_MAX_SEGMENTS 8 ++#define V4L2_AV1_MAX_OPERATING_POINTS (1 << 5) /* 5 bits to encode */ ++#define V4L2_AV1_REFS_PER_FRAME 7 ++#define V4L2_AV1_MAX_NUM_Y_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CB_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_MAX_NUM_CR_POINTS (1 << 4) /* 4 bits to encode */ ++#define V4L2_AV1_AR_COEFFS_SIZE 25 /* (2 * 3 * (3 + 1)) + 1 */ ++#define V4L2_AV1_MAX_NUM_PLANES 3 ++#define V4L2_AV1_MAX_TILE_COLS 64 ++#define V4L2_AV1_MAX_TILE_ROWS 64 ++#define V4L2_AV1_MAX_TILE_COUNT 512 ++ ++#define V4L2_AV1_SEQUENCE_FLAG_STILL_PICTURE 0x00000001 ++#define V4L2_AV1_SEQUENCE_FLAG_USE_128X128_SUPERBLOCK 0x00000002 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_FILTER_INTRA 0x00000004 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTRA_EDGE_FILTER 0x00000008 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_INTERINTRA_COMPOUND 0x00000010 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_MASKED_COMPOUND 0x00000020 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_WARPED_MOTION 0x00000040 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_DUAL_FILTER 0x00000080 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_ORDER_HINT 0x00000100 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_JNT_COMP 0x00000200 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_SUPERRES 0x00000800 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_CDEF 0x00001000 ++#define V4L2_AV1_SEQUENCE_FLAG_ENABLE_RESTORATION 0x00002000 ++#define V4L2_AV1_SEQUENCE_FLAG_MONO_CHROME 0x00004000 ++#define V4L2_AV1_SEQUENCE_FLAG_COLOR_RANGE 0x00008000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_X 0x00010000 ++#define V4L2_AV1_SEQUENCE_FLAG_SUBSAMPLING_Y 0x00020000 ++#define V4L2_AV1_SEQUENCE_FLAG_FILM_GRAIN_PARAMS_PRESENT 0x00040000 ++#define V4L2_AV1_SEQUENCE_FLAG_SEPARATE_UV_DELTA_Q 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_SEQUENCE (V4L2_CID_CODEC_STATELESS_BASE + 500) ++/** ++ * struct v4l2_ctrl_av1_sequence - AV1 Sequence ++ * ++ * Represents an AV1 Sequence OBU. See section 5.5 "Sequence header OBU syntax" ++ * for more details. ++ * ++ * @flags: See V4L2_AV1_SEQUENCE_FLAG_{}. ++ * @seq_profile: specifies the features that can be used in the coded video ++ * sequence. ++ * @order_hint_bits: specifies the number of bits used for the order_hint field ++ * at each frame. ++ * @bit_depth: the bitdepth to use for the sequence as described in section ++ * 5.5.2 "Color config syntax". ++ * @reserved: padding field. Should be zeroed by applications. ++ * @max_frame_width_minus_1: specifies the maximum frame width minus 1 for the ++ * frames represented by this sequence header. ++ * @max_frame_height_minus_1: specifies the maximum frame height minus 1 for the ++ * frames represented by this sequence header. ++ */ ++struct v4l2_ctrl_av1_sequence { ++ __u32 flags; ++ __u8 seq_profile; ++ __u8 order_hint_bits; ++ __u8 bit_depth; ++ __u8 reserved; ++ __u16 max_frame_width_minus_1; ++ __u16 max_frame_height_minus_1; ++}; ++ ++#define V4L2_CID_STATELESS_AV1_TILE_GROUP_ENTRY (V4L2_CID_CODEC_STATELESS_BASE + 501) ++/** ++ * struct v4l2_ctrl_av1_tile_group_entry - AV1 Tile Group entry ++ * ++ * Represents a single AV1 tile inside an AV1 Tile Group. Note that MiRowStart, ++ * MiRowEnd, MiColStart and MiColEnd can be retrieved from struct ++ * v4l2_av1_tile_info in struct v4l2_ctrl_av1_frame using tile_row and ++ * tile_col. See section 6.10.1 "General tile group OBU semantics" for more ++ * details. ++ * ++ * @tile_offset: offset from the OBU data, i.e. where the coded tile data ++ * actually starts. ++ * @tile_size: specifies the size in bytes of the coded tile. Equivalent to ++ * "TileSize" in the AV1 Specification. ++ * @tile_row: specifies the row of the current tile. Equivalent to "TileRow" in ++ * the AV1 Specification. ++ * @tile_col: specifies the col of the current tile. Equivalent to "TileCol" in ++ * the AV1 Specification. ++ */ ++struct v4l2_ctrl_av1_tile_group_entry { ++ __u32 tile_offset; ++ __u32 tile_size; ++ __u32 tile_row; ++ __u32 tile_col; ++}; ++ ++/** ++ * enum v4l2_av1_warp_model - AV1 Warp Model as described in section 3 ++ * "Symbols and abbreviated terms" of the AV1 Specification. ++ * ++ * @V4L2_AV1_WARP_MODEL_IDENTITY: Warp model is just an identity transform. ++ * @V4L2_AV1_WARP_MODEL_TRANSLATION: Warp model is a pure translation. ++ * @V4L2_AV1_WARP_MODEL_ROTZOOM: Warp model is a rotation + symmetric zoom + ++ * translation. ++ * @V4L2_AV1_WARP_MODEL_AFFINE: Warp model is a general affine transform. ++ */ ++enum v4l2_av1_warp_model { ++ V4L2_AV1_WARP_MODEL_IDENTITY = 0, ++ V4L2_AV1_WARP_MODEL_TRANSLATION = 1, ++ V4L2_AV1_WARP_MODEL_ROTZOOM = 2, ++ V4L2_AV1_WARP_MODEL_AFFINE = 3, ++}; ++ ++/** ++ * enum v4l2_av1_reference_frame - AV1 reference frames ++ * ++ * @V4L2_AV1_REF_INTRA_FRAME: Intra Frame Reference ++ * @V4L2_AV1_REF_LAST_FRAME: Last Reference Frame ++ * @V4L2_AV1_REF_LAST2_FRAME: Last2 Reference Frame ++ * @V4L2_AV1_REF_LAST3_FRAME: Last3 Reference Frame ++ * @V4L2_AV1_REF_GOLDEN_FRAME: Golden Reference Frame ++ * @V4L2_AV1_REF_BWDREF_FRAME: BWD Reference Frame ++ * @V4L2_AV1_REF_ALTREF2_FRAME: Alternative2 Reference Frame ++ * @V4L2_AV1_REF_ALTREF_FRAME: Alternative Reference Frame ++ */ ++enum v4l2_av1_reference_frame { ++ V4L2_AV1_REF_INTRA_FRAME = 0, ++ V4L2_AV1_REF_LAST_FRAME = 1, ++ V4L2_AV1_REF_LAST2_FRAME = 2, ++ V4L2_AV1_REF_LAST3_FRAME = 3, ++ V4L2_AV1_REF_GOLDEN_FRAME = 4, ++ V4L2_AV1_REF_BWDREF_FRAME = 5, ++ V4L2_AV1_REF_ALTREF2_FRAME = 6, ++ V4L2_AV1_REF_ALTREF_FRAME = 7, ++}; ++ ++#define V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) (1 << (ref)) ++ ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_GLOBAL 0x1 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_ROT_ZOOM 0x2 ++#define V4L2_AV1_GLOBAL_MOTION_FLAG_IS_TRANSLATION 0x4 ++/** ++ * struct v4l2_av1_global_motion - AV1 Global Motion parameters as described in ++ * section 6.8.17 "Global motion params semantics" of the AV1 specification. ++ * ++ * @flags: A bitfield containing the flags per reference frame. See ++ * V4L2_AV1_GLOBAL_MOTION_FLAG_{} ++ * @type: The type of global motion transform used. ++ * @params: this field has the same meaning as "gm_params" in the AV1 ++ * specification. ++ * @invalid: bitfield indicating whether the global motion params are invalid ++ * for a given reference frame. See section 7.11.3.6 Setup shear process and ++ * the variable "warpValid". Use V4L2_AV1_GLOBAL_MOTION_IS_INVALID(ref) to ++ * create a suitable mask. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++ ++struct v4l2_av1_global_motion { ++ __u8 flags[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ enum v4l2_av1_warp_model type[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s32 params[V4L2_AV1_TOTAL_REFS_PER_FRAME][6]; ++ __u8 invalid; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_restoration_type - AV1 Frame Restoration Type ++ * @V4L2_AV1_FRAME_RESTORE_NONE: no filtering is applied. ++ * @V4L2_AV1_FRAME_RESTORE_WIENER: Wiener filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SGRPROJ: self guided filter process is invoked. ++ * @V4L2_AV1_FRAME_RESTORE_SWITCHABLE: restoration filter is swichtable. ++ */ ++enum v4l2_av1_frame_restoration_type { ++ V4L2_AV1_FRAME_RESTORE_NONE = 0, ++ V4L2_AV1_FRAME_RESTORE_WIENER = 1, ++ V4L2_AV1_FRAME_RESTORE_SGRPROJ = 2, ++ V4L2_AV1_FRAME_RESTORE_SWITCHABLE = 3, ++}; ++ ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_LR 0x1 ++#define V4L2_AV1_LOOP_RESTORATION_FLAG_USES_CHROMA_LR 0x2 ++ ++/** ++ * struct v4l2_av1_loop_restoration - AV1 Loop Restauration as described in ++ * section 6.10.15 "Loop restoration params semantics" of the AV1 specification. ++ * ++ * @flags: See V4L2_AV1_LOOP_RESTORATION_FLAG_{}. ++ * @lr_unit_shift: specifies if the luma restoration size should be halved. ++ * @lr_uv_shift: specifies if the chroma size should be half the luma size. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @frame_restoration_type: specifies the type of restoration used for each ++ * plane. See enum v4l2_av1_frame_restoration_type. ++ * @loop_restoration_size: specifies the size of loop restoration units in units ++ * of samples in the current plane. ++ */ ++struct v4l2_av1_loop_restoration { ++ __u8 flags; ++ __u8 lr_unit_shift; ++ __u8 lr_uv_shift; ++ __u8 reserved; ++ enum v4l2_av1_frame_restoration_type frame_restoration_type[V4L2_AV1_NUM_PLANES_MAX]; ++ __u32 loop_restoration_size[V4L2_AV1_MAX_NUM_PLANES]; ++}; ++ ++/** ++ * struct v4l2_av1_cdef - AV1 CDEF params semantics as described in section ++ * 6.10.14 "CDEF params semantics" of the AV1 specification ++ * ++ * @damping_minus_3: controls the amount of damping in the deringing filter. ++ * @bits: specifies the number of bits needed to specify which CDEF filter to ++ * apply. ++ * @y_pri_strength: specifies the strength of the primary filter. ++ * @y_sec_strength: specifies the strength of the secondary filter. ++ * @uv_pri_strength: specifies the strength of the primary filter. ++ * @uv_sec_strength: specifies the strength of the secondary filter. ++ */ ++struct v4l2_av1_cdef { ++ __u8 damping_minus_3; ++ __u8 bits; ++ __u8 y_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 y_sec_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_pri_strength[V4L2_AV1_CDEF_MAX]; ++ __u8 uv_sec_strength[V4L2_AV1_CDEF_MAX]; ++}; ++ ++#define V4L2_AV1_SEGMENTATION_FLAG_ENABLED 0x1 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_MAP 0x2 ++#define V4L2_AV1_SEGMENTATION_FLAG_TEMPORAL_UPDATE 0x4 ++#define V4L2_AV1_SEGMENTATION_FLAG_UPDATE_DATA 0x8 ++#define V4L2_AV1_SEGMENTATION_FLAG_SEG_ID_PRE_SKIP 0x10 ++ ++/** ++ * enum v4l2_av1_segment_feature - AV1 segment features as described in section ++ * 3 "Symbols and abbreviated terms" of the AV1 specification. ++ * ++ * @V4L2_AV1_SEG_LVL_ALT_Q: Index for quantizer segment feature. ++ * @V4L2_AV1_SEG_LVL_ALT_LF_Y_V: Index for vertical luma loop filter segment ++ * feature. ++ * @V4L2_AV1_SEG_LVL_REF_FRAME: Index for reference frame segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_SKIP: Index for skip segment feature. ++ * @V4L2_AV1_SEG_LVL_REF_GLOBALMV: Index for global mv feature. ++ * @V4L2_AV1_SEG_LVL_MAX: Number of segment features. ++ */ ++enum v4l2_av1_segment_feature { ++ V4L2_AV1_SEG_LVL_ALT_Q = 0, ++ V4L2_AV1_SEG_LVL_ALT_LF_Y_V = 1, ++ V4L2_AV1_SEG_LVL_REF_FRAME = 5, ++ V4L2_AV1_SEG_LVL_REF_SKIP = 6, ++ V4L2_AV1_SEG_LVL_REF_GLOBALMV = 7, ++ V4L2_AV1_SEG_LVL_MAX = 8 ++}; ++ ++#define V4L2_AV1_SEGMENT_FEATURE_ENABLED(id) (1 << (id)) ++ ++/** ++ * struct v4l2_av1_segmentation - AV1 Segmentation params as defined in section ++ * 6.8.13 "Segmentation params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_SEGMENTATION_FLAG_{}. ++ * @last_active_seg_id: indicates the highest numbered segment id that has some ++ * enabled feature. This is used when decoding the segment id to only decode ++ * choices corresponding to used segments. ++ * @feature_enabled: bitmask defining which features are enabled in each ++ * segment. Use V4L2_AV1_SEGMENT_FEATURE_ENABLED to build a suitable mask. ++ * @feature_data: data attached to each feature. Data entry is only valid if the ++ * feature is enabled ++ */ ++struct v4l2_av1_segmentation { ++ __u8 flags; ++ __u8 last_active_seg_id; ++ __u8 feature_enabled[V4L2_AV1_MAX_SEGMENTS]; ++ __s16 feature_data[V4L2_AV1_MAX_SEGMENTS][V4L2_AV1_SEG_LVL_MAX]; ++}; ++ ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_ENABLED 0x1 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_UPDATE 0x2 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_PRESENT 0x4 ++#define V4L2_AV1_LOOP_FILTER_FLAG_DELTA_LF_MULTI 0x8 ++ ++/** ++ * struct v4l2_av1_loop_filter - AV1 Loop filter params as defined in section ++ * 6.8.10 "Loop filter semantics" and 6.8.16 "Loop filter delta parameters ++ * semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_LOOP_FILTER_FLAG_{} ++ * @level: an array containing loop filter strength values. Different loop ++ * filter strength values from the array are used depending on the image plane ++ * being filtered, and the edge direction (vertical or horizontal) being ++ * filtered. ++ * @sharpness: indicates the sharpness level. The loop_filter_level and ++ * loop_filter_sharpness together determine when a block edge is filtered, and ++ * by how much the filtering can change the sample values. The loop filter ++ * process is described in section 7.14 of the AV1 specification. ++ * @ref_deltas: contains the adjustment needed for the filter level based on the ++ * chosen reference frame. If this syntax element is not present, it maintains ++ * its previous value. ++ * @mode_deltas: contains the adjustment needed for the filter level based on ++ * the chosen mode. If this syntax element is not present, it maintains its ++ * previous value. ++ * @delta_lf_res: specifies the left shift which should be applied to decoded ++ * loop filter delta values. ++ */ ++struct v4l2_av1_loop_filter { ++ __u8 flags; ++ __u8 level[4]; ++ __u8 sharpness; ++ __s8 ref_deltas[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 mode_deltas[2]; ++ __u8 delta_lf_res; ++}; ++ ++#define V4L2_AV1_QUANTIZATION_FLAG_DIFF_UV_DELTA 0x1 ++#define V4L2_AV1_QUANTIZATION_FLAG_USING_QMATRIX 0x2 ++#define V4L2_AV1_QUANTIZATION_FLAG_DELTA_Q_PRESENT 0x4 ++ ++/** ++ * struct v4l2_av1_quantization - AV1 Quantization params as defined in section ++ * 6.8.11 "Quantization params semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_QUANTIZATION_FLAG_{} ++ * @base_q_idx: indicates the base frame qindex. This is used for Y AC ++ * coefficients and as the base value for the other quantizers. ++ * @delta_q_y_dc: indicates the Y DC quantizer relative to base_q_idx. ++ * @delta_q_u_dc: indicates the U DC quantizer relative to base_q_idx. ++ * @delta_q_u_ac: indicates the U AC quantizer relative to base_q_idx. ++ * @delta_q_v_dc: indicates the V DC quantizer relative to base_q_idx. ++ * @delta_q_v_ac: indicates the V AC quantizer relative to base_q_idx. ++ * @qm_y: specifies the level in the quantizer matrix that should be used for ++ * luma plane decoding. ++ * @qm_u: specifies the level in the quantizer matrix that should be used for ++ * chroma U plane decoding. ++ * @qm_v: specifies the level in the quantizer matrix that should be used for ++ * chroma V plane decoding. ++ * @delta_q_res: specifies the left shift which should be applied to decoded ++ * quantizer index delta values. ++ */ ++struct v4l2_av1_quantization { ++ __u8 flags; ++ __u8 base_q_idx; ++ __s8 delta_q_y_dc; ++ __s8 delta_q_u_dc; ++ __s8 delta_q_u_ac; ++ __s8 delta_q_v_dc; ++ __s8 delta_q_v_ac; ++ __u8 qm_y; ++ __u8 qm_u; ++ __u8 qm_v; ++ __u8 delta_q_res; ++}; ++ ++#define V4L2_AV1_TILE_INFO_FLAG_UNIFORM_TILE_SPACING 0x1 ++ ++/** ++ * struct v4l2_av1_tile_info - AV1 Tile info as defined in section 6.8.14 "Tile ++ * info semantics" of the AV1 specification. ++ * ++ * @flags: see V4L2_AV1_TILE_INFO_FLAG_{} ++ * @context_update_tile_id: specifies which tile to use for the CDF update. ++ * @tile_rows: specifies the number of tiles down the frame. ++ * @tile_cols: specifies the number of tiles across the frame. ++ * @mi_col_starts: an array specifying the start column (in units of 4x4 luma ++ * samples) for each tile across the image. ++ * @mi_row_starts: an array specifying the start row (in units of 4x4 luma ++ * samples) for each tile down the image. ++ * @width_in_sbs_minus_1: specifies the width of a tile minus 1 in units of ++ * superblocks. ++ * @height_in_sbs_minus_1: specifies the height of a tile minus 1 in units of ++ * superblocks. ++ * @tile_size_bytes: specifies the number of bytes needed to code each tile ++ * size. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_av1_tile_info { ++ __u8 flags; ++ __u8 context_update_tile_id; ++ __u8 tile_cols; ++ __u8 tile_rows; ++ __u32 mi_col_starts[V4L2_AV1_MAX_TILE_COLS + 1]; ++ __u32 mi_row_starts[V4L2_AV1_MAX_TILE_ROWS + 1]; ++ __u32 width_in_sbs_minus_1[V4L2_AV1_MAX_TILE_COLS]; ++ __u32 height_in_sbs_minus_1[V4L2_AV1_MAX_TILE_ROWS]; ++ __u8 tile_size_bytes; ++ __u8 reserved[3]; ++}; ++ ++/** ++ * enum v4l2_av1_frame_type - AV1 Frame Type ++ * ++ * @V4L2_AV1_KEY_FRAME: Key frame ++ * @V4L2_AV1_INTER_FRAME: Inter frame ++ * @V4L2_AV1_INTRA_ONLY_FRAME: Intra-only frame ++ * @V4L2_AV1_SWITCH_FRAME: Switch frame ++ */ ++enum v4l2_av1_frame_type { ++ V4L2_AV1_KEY_FRAME = 0, ++ V4L2_AV1_INTER_FRAME = 1, ++ V4L2_AV1_INTRA_ONLY_FRAME = 2, ++ V4L2_AV1_SWITCH_FRAME = 3 ++}; ++ ++/** ++ * enum v4l2_av1_interpolation_filter - AV1 interpolation filter types ++ * ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP: eight tap filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH: eight tap smooth filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP: eight tap sharp filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_BILINEAR: bilinear filter ++ * @V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE: filter selection is signaled at ++ * the block level ++ * ++ * See section 6.8.9 "Interpolation filter semantics" of the AV1 specification ++ * for more details. ++ */ ++enum v4l2_av1_interpolation_filter { ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP = 0, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SMOOTH = 1, ++ V4L2_AV1_INTERPOLATION_FILTER_EIGHTTAP_SHARP = 2, ++ V4L2_AV1_INTERPOLATION_FILTER_BILINEAR = 3, ++ V4L2_AV1_INTERPOLATION_FILTER_SWITCHABLE = 4, ++}; ++ ++/** ++ * enum v4l2_av1_tx_mode - AV1 Tx mode as described in section 6.8.21 "TX mode ++ * semantics" of the AV1 specification. ++ * @V4L2_AV1_TX_MODE_ONLY_4X4: the inverse transform will use only 4x4 ++ * transforms ++ * @V4L2_AV1_TX_MODE_LARGEST: the inverse transform will use the largest ++ * transform size that fits inside the block ++ * @V4L2_AV1_TX_MODE_SELECT: the choice of transform size is specified ++ * explicitly for each block. ++ */ ++enum v4l2_av1_tx_mode { ++ V4L2_AV1_TX_MODE_ONLY_4X4 = 0, ++ V4L2_AV1_TX_MODE_LARGEST = 1, ++ V4L2_AV1_TX_MODE_SELECT = 2 ++}; ++ ++#define V4L2_AV1_FRAME_FLAG_SHOW_FRAME 0x00000001 ++#define V4L2_AV1_FRAME_FLAG_SHOWABLE_FRAME 0x00000002 ++#define V4L2_AV1_FRAME_FLAG_ERROR_RESILIENT_MODE 0x00000004 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_CDF_UPDATE 0x00000008 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_SCREEN_CONTENT_TOOLS 0x00000010 ++#define V4L2_AV1_FRAME_FLAG_FORCE_INTEGER_MV 0x00000020 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_INTRABC 0x00000040 ++#define V4L2_AV1_FRAME_FLAG_USE_SUPERRES 0x00000080 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_HIGH_PRECISION_MV 0x00000100 ++#define V4L2_AV1_FRAME_FLAG_IS_MOTION_MODE_SWITCHABLE 0x00000200 ++#define V4L2_AV1_FRAME_FLAG_USE_REF_FRAME_MVS 0x00000400 ++#define V4L2_AV1_FRAME_FLAG_DISABLE_FRAME_END_UPDATE_CDF 0x00000800 ++#define V4L2_AV1_FRAME_FLAG_ALLOW_WARPED_MOTION 0x00001000 ++#define V4L2_AV1_FRAME_FLAG_REFERENCE_SELECT 0x00002000 ++#define V4L2_AV1_FRAME_FLAG_REDUCED_TX_SET 0x00004000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_ALLOWED 0x00008000 ++#define V4L2_AV1_FRAME_FLAG_SKIP_MODE_PRESENT 0x00010000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_SIZE_OVERRIDE 0x00020000 ++#define V4L2_AV1_FRAME_FLAG_BUFFER_REMOVAL_TIME_PRESENT 0x00040000 ++#define V4L2_AV1_FRAME_FLAG_FRAME_REFS_SHORT_SIGNALING 0x00080000 ++ ++#define V4L2_CID_STATELESS_AV1_FRAME (V4L2_CID_CODEC_STATELESS_BASE + 502) ++/** ++ * struct v4l2_ctrl_av1_frame - Represents an AV1 Frame Header OBU. ++ * ++ * @tile_info: tile info ++ * @quantization: quantization params ++ * @segmentation: segmentation params ++ * @superres_denom: the denominator for the upscaling ratio. ++ * @loop_filter: loop filter params ++ * @cdef: cdef params ++ * @skip_mode_frame: specifies the frames to use for compound prediction when ++ * skip_mode is equal to 1. ++ * @primary_ref_frame: specifies which reference frame contains the CDF values ++ * and other state that should be loaded at the start of the frame. ++ * @loop_restoration: loop restoration params ++ * @global_motion: global motion params ++ * @flags: see V4L2_AV1_FRAME_FLAG_{} ++ * @frame_type: specifies the AV1 frame type ++ * @order_hint: specifies OrderHintBits least significant bits of the expected ++ * output order for this frame. ++ * @upscaled_width: the upscaled width. ++ * @interpolation_filter: specifies the filter selection used for performing ++ * inter prediction. ++ * @tx_mode: specifies how the transform size is determined. ++ * @frame_width_minus_1: add 1 to get the frame's width. ++ * @frame_height_minus_1: add 1 to get the frame's height ++ * @render_width_minus_1: add 1 to get the render width of the frame in luma ++ * samples. ++ * @render_height_minus_1: add 1 to get the render height of the frame in luma ++ * samples. ++ * @current_frame_id: specifies the frame id number for the current frame. Frame ++ * id numbers are additional information that do not affect the decoding ++ * process, but provide decoders with a way of detecting missing reference ++ * frames so that appropriate action can be taken. ++ * @buffer_removal_time: specifies the frame removal time in units of DecCT clock ++ * ticks counted from the removal time of the last random access point for ++ * operating point opNum. ++ * @reserved: padding field. Should be zeroed by applications. ++ * @order_hints: specifies the expected output order hint for each reference ++ * frame. This field corresponds to the OrderHints variable from the ++ * specification (section 5.9.2 "Uncompressed header syntax"). As such, this is ++ * only used for non-intra frames and ignored otherwise. order_hints[0] is ++ * always ignored. ++ * @reference_frame_ts: the V4L2 timestamp of the reference frame slots. ++ * @ref_frame_idx: used to index into @reference_frame_ts when decoding ++ * inter-frames. The meaning of this array is the same as in the specification. ++ * The timestamp refers to the timestamp field in struct v4l2_buffer. Use ++ * v4l2_timeval_to_ns() to convert the struct timeval to a __u64. ++ * @refresh_frame_flags: contains a bitmask that specifies which reference frame ++ * slots will be updated with the current frame after it is decoded. ++ */ ++struct v4l2_ctrl_av1_frame { ++ struct v4l2_av1_tile_info tile_info; ++ struct v4l2_av1_quantization quantization; ++ __u8 superres_denom; ++ struct v4l2_av1_segmentation segmentation; ++ struct v4l2_av1_loop_filter loop_filter; ++ struct v4l2_av1_cdef cdef; ++ __u8 skip_mode_frame[2]; ++ __u8 primary_ref_frame; ++ struct v4l2_av1_loop_restoration loop_restoration; ++ struct v4l2_av1_global_motion global_motion; ++ __u32 flags; ++ enum v4l2_av1_frame_type frame_type; ++ __u32 order_hint; ++ __u32 upscaled_width; ++ enum v4l2_av1_interpolation_filter interpolation_filter; ++ enum v4l2_av1_tx_mode tx_mode; ++ __u32 frame_width_minus_1; ++ __u32 frame_height_minus_1; ++ __u16 render_width_minus_1; ++ __u16 render_height_minus_1; ++ ++ __u32 current_frame_id; ++ __u32 buffer_removal_time[V4L2_AV1_MAX_OPERATING_POINTS]; ++ __u8 reserved[4]; ++ __u32 order_hints[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __u64 reference_frame_ts[V4L2_AV1_TOTAL_REFS_PER_FRAME]; ++ __s8 ref_frame_idx[V4L2_AV1_REFS_PER_FRAME]; ++ __u8 refresh_frame_flags; ++}; ++ ++#define V4L2_AV1_FILM_GRAIN_FLAG_APPLY_GRAIN 0x1 ++#define V4L2_AV1_FILM_GRAIN_FLAG_UPDATE_GRAIN 0x2 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CHROMA_SCALING_FROM_LUMA 0x4 ++#define V4L2_AV1_FILM_GRAIN_FLAG_OVERLAP 0x8 ++#define V4L2_AV1_FILM_GRAIN_FLAG_CLIP_TO_RESTRICTED_RANGE 0x10 ++ ++#define V4L2_CID_STATELESS_AV1_FILM_GRAIN (V4L2_CID_CODEC_STATELESS_BASE + 505) ++/** ++ * struct v4l2_ctrl_av1_film_grain - AV1 Film Grain parameters. ++ * ++ * Film grain parameters as specified by section 6.8.20 of the AV1 Specification. ++ * ++ * @flags: see V4L2_AV1_FILM_GRAIN_{}. ++ * @cr_mult: represents a multiplier for the cr component used in derivation of ++ * the input index to the cr component scaling function. ++ * @grain_seed: specifies the starting value for the pseudo-random numbers used ++ * during film grain synthesis. ++ * @film_grain_params_ref_idx: indicates which reference frame contains the ++ * film grain parameters to be used for this frame. ++ * @num_y_points: specifies the number of points for the piece-wise linear ++ * scaling function of the luma component. ++ * @point_y_value: represents the x (luma value) coordinate for the i-th point ++ * of the piecewise linear scaling function for luma component. The values are ++ * signaled on the scale of 0..255. In case of 10 bit video, these values ++ * correspond to luma values divided by 4. In case of 12 bit video, these values ++ * correspond to luma values divided by 16. ++ * @point_y_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for luma component. ++ * @num_cb_points: specifies the number of points for the piece-wise linear ++ * scaling function of the cb component. ++ * @point_cb_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cb component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cb_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cb component. ++ * @num_cr_points: specifies represents the number of points for the piece-wise ++ * linear scaling function of the cr component. ++ * @point_cr_value: represents the x coordinate for the i-th point of the ++ * piece-wise linear scaling function for cr component. The values are signaled ++ * on the scale of 0..255. ++ * @point_cr_scaling: represents the scaling (output) value for the i-th point ++ * of the piecewise linear scaling function for cr component. ++ * @grain_scaling_minus_8: represents the shift – 8 applied to the values of the ++ * chroma component. The grain_scaling_minus_8 can take values of 0..3 and ++ * determines the range and quantization step of the standard deviation of film ++ * grain. ++ * @ar_coeff_lag: specifies the number of auto-regressive coefficients for luma ++ * and chroma. ++ * @ar_coeffs_y_plus_128: specifies auto-regressive coefficients used for the Y ++ * plane. ++ * @ar_coeffs_cb_plus_128: specifies auto-regressive coefficients used for the U ++ * plane. ++ * @ar_coeffs_cr_plus_128: specifies auto-regressive coefficients used for the V ++ * plane. ++ * @ar_coeff_shift_minus_6: specifies the range of the auto-regressive ++ * coefficients. Values of 0, 1, 2, and 3 correspond to the ranges for ++ * auto-regressive coefficients of [-2, 2), [-1, 1), [-0.5, 0.5) and [-0.25, ++ * 0.25) respectively. ++ * @grain_scale_shift: specifies how much the Gaussian random numbers should be ++ * scaled down during the grain synthesis process. ++ * @cb_mult: represents a multiplier for the cb component used in derivation of ++ * the input index to the cb component scaling function. ++ * @cb_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cb component scaling function. ++ * @cr_luma_mult: represents a multiplier for the average luma component used in ++ * derivation of the input index to the cr component scaling function. ++ * @cb_offset: represents an offset used in derivation of the input index to the ++ * cb component scaling function. ++ * @cr_offset: represents an offset used in derivation of the input index to the ++ * cr component scaling function. ++ * @reserved: padding field. Should be zeroed by applications. ++ */ ++struct v4l2_ctrl_av1_film_grain { ++ __u8 flags; ++ __u8 cr_mult; ++ __u16 grain_seed; ++ __u8 film_grain_params_ref_idx; ++ __u8 num_y_points; ++ __u8 point_y_value[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 point_y_scaling[V4L2_AV1_MAX_NUM_Y_POINTS]; ++ __u8 num_cb_points; ++ __u8 point_cb_value[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 point_cb_scaling[V4L2_AV1_MAX_NUM_CB_POINTS]; ++ __u8 num_cr_points; ++ __u8 point_cr_value[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 point_cr_scaling[V4L2_AV1_MAX_NUM_CR_POINTS]; ++ __u8 grain_scaling_minus_8; ++ __u8 ar_coeff_lag; ++ __u8 ar_coeffs_y_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cb_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeffs_cr_plus_128[V4L2_AV1_AR_COEFFS_SIZE]; ++ __u8 ar_coeff_shift_minus_6; ++ __u8 grain_scale_shift; ++ __u8 cb_mult; ++ __u8 cb_luma_mult; ++ __u8 cr_luma_mult; ++ __u16 cb_offset; ++ __u16 cr_offset; ++ __u8 reserved[4]; ++}; ++ + /* MPEG-compression definitions kept for backwards compatibility */ + #define V4L2_CTRL_CLASS_MPEG V4L2_CTRL_CLASS_CODEC + #define V4L2_CID_MPEG_CLASS V4L2_CID_CODEC_CLASS +--- a/x86/usr/include/linux/v4l2-subdev.h ++++ b/x86/usr/include/linux/v4l2-subdev.h +@@ -239,7 +239,7 @@ struct v4l2_subdev_routing { + * set (which is the default), the 'stream' fields will be forced to 0 by the + * kernel. + */ +- #define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1U << 0) ++#define V4L2_SUBDEV_CLIENT_CAP_STREAMS (1ULL << 0) + + /** + * struct v4l2_subdev_client_capability - Capabilities of the client accessing +--- a/x86/usr/include/linux/vfio.h ++++ b/x86/usr/include/linux/vfio.h +@@ -511,6 +511,9 @@ struct vfio_region_info_cap_nvlink2_lnks + * then add and unmask vectors, it's up to userspace to make the decision + * whether to allocate the maximum supported number of vectors or tear + * down setup and incrementally increase the vectors as each is enabled. ++ * Absence of the NORESIZE flag indicates that vectors can be enabled ++ * and disabled dynamically without impacting other vectors within the ++ * index. + */ + struct vfio_irq_info { + __u32 argsz; +@@ -646,6 +649,15 @@ enum { + VFIO_CCW_NUM_IRQS + }; + ++/* ++ * The vfio-ap bus driver makes use of the following IRQ index mapping. ++ * Unimplemented IRQ types return a count of zero. ++ */ ++enum { ++ VFIO_AP_REQ_IRQ_INDEX, ++ VFIO_AP_NUM_IRQS ++}; ++ + /** + * VFIO_DEVICE_GET_PCI_HOT_RESET_INFO - _IOWR(VFIO_TYPE, VFIO_BASE + 12, + * struct vfio_pci_hot_reset_info) +--- a/x86/usr/include/linux/vhost.h ++++ b/x86/usr/include/linux/vhost.h +@@ -45,6 +45,25 @@ + #define VHOST_SET_LOG_BASE _IOW(VHOST_VIRTIO, 0x04, __u64) + /* Specify an eventfd file descriptor to signal on log write. */ + #define VHOST_SET_LOG_FD _IOW(VHOST_VIRTIO, 0x07, int) ++/* By default, a device gets one vhost_worker that its virtqueues share. This ++ * command allows the owner of the device to create an additional vhost_worker ++ * for the device. It can later be bound to 1 or more of its virtqueues using ++ * the VHOST_ATTACH_VRING_WORKER command. ++ * ++ * This must be called after VHOST_SET_OWNER and the caller must be the owner ++ * of the device. The new thread will inherit caller's cgroups and namespaces, ++ * and will share the caller's memory space. The new thread will also be ++ * counted against the caller's RLIMIT_NPROC value. ++ * ++ * The worker's ID used in other commands will be returned in ++ * vhost_worker_state. ++ */ ++#define VHOST_NEW_WORKER _IOR(VHOST_VIRTIO, 0x8, struct vhost_worker_state) ++/* Free a worker created with VHOST_NEW_WORKER if it's not attached to any ++ * virtqueue. If userspace is not able to call this for workers its created, ++ * the kernel will free all the device's workers when the device is closed. ++ */ ++#define VHOST_FREE_WORKER _IOW(VHOST_VIRTIO, 0x9, struct vhost_worker_state) + + /* Ring setup. */ + /* Set number of descriptors in ring. This parameter can not +@@ -70,6 +89,18 @@ + #define VHOST_VRING_BIG_ENDIAN 1 + #define VHOST_SET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x13, struct vhost_vring_state) + #define VHOST_GET_VRING_ENDIAN _IOW(VHOST_VIRTIO, 0x14, struct vhost_vring_state) ++/* Attach a vhost_worker created with VHOST_NEW_WORKER to one of the device's ++ * virtqueues. ++ * ++ * This will replace the virtqueue's existing worker. If the replaced worker ++ * is no longer attached to any virtqueues, it can be freed with ++ * VHOST_FREE_WORKER. ++ */ ++#define VHOST_ATTACH_VRING_WORKER _IOW(VHOST_VIRTIO, 0x15, \ ++ struct vhost_vring_worker) ++/* Return the vring worker's ID */ ++#define VHOST_GET_VRING_WORKER _IOWR(VHOST_VIRTIO, 0x16, \ ++ struct vhost_vring_worker) + + /* The following ioctls use eventfd file descriptors to signal and poll + * for events. */ +@@ -188,4 +219,12 @@ + */ + #define VHOST_VDPA_RESUME _IO(VHOST_VIRTIO, 0x7E) + ++/* Get the group for the descriptor table including driver & device areas ++ * of a virtqueue: read index, write group in num. ++ * The virtqueue index is stored in the index field of vhost_vring_state. ++ * The group ID of the descriptor table for this specific virtqueue ++ * is returned via num field of vhost_vring_state. ++ */ ++#define VHOST_VDPA_GET_VRING_DESC_GROUP _IOWR(VHOST_VIRTIO, 0x7F, \ ++ struct vhost_vring_state) + #endif +--- a/x86/usr/include/linux/vhost_types.h ++++ b/x86/usr/include/linux/vhost_types.h +@@ -47,6 +47,22 @@ struct vhost_vring_addr { + __u64 log_guest_addr; + }; + ++struct vhost_worker_state { ++ /* ++ * For VHOST_NEW_WORKER the kernel will return the new vhost_worker id. ++ * For VHOST_FREE_WORKER this must be set to the id of the vhost_worker ++ * to free. ++ */ ++ unsigned int worker_id; ++}; ++ ++struct vhost_vring_worker { ++ /* vring index */ ++ unsigned int index; ++ /* The id of the vhost_worker returned from VHOST_NEW_WORKER */ ++ unsigned int worker_id; ++}; ++ + /* no alignment requirement */ + struct vhost_iotlb_msg { + __u64 iova; +@@ -165,5 +181,16 @@ struct vhost_vdpa_iova_range { + #define VHOST_BACKEND_F_SUSPEND 0x4 + /* Device can be resumed */ + #define VHOST_BACKEND_F_RESUME 0x5 ++/* Device supports the driver enabling virtqueues both before and after ++ * DRIVER_OK ++ */ ++#define VHOST_BACKEND_F_ENABLE_AFTER_DRIVER_OK 0x6 ++/* Device may expose the virtqueue's descriptor area, driver area and ++ * device area to a different group for ASID binding than where its ++ * buffers may reside. Requires VHOST_BACKEND_F_IOTLB_ASID. ++ */ ++#define VHOST_BACKEND_F_DESC_ASID 0x7 ++/* IOTLB don't flush memory mapping across device reset */ ++#define VHOST_BACKEND_F_IOTLB_PERSIST 0x8 + + #endif +--- a/x86/usr/include/linux/videodev2.h ++++ b/x86/usr/include/linux/videodev2.h +@@ -731,6 +731,7 @@ struct v4l2_pix_format { + #define V4L2_PIX_FMT_FWHT_STATELESS v4l2_fourcc('S', 'F', 'W', 'H') /* Stateless FWHT (vicodec) */ + #define V4L2_PIX_FMT_H264_SLICE v4l2_fourcc('S', '2', '6', '4') /* H264 parsed slices */ + #define V4L2_PIX_FMT_HEVC_SLICE v4l2_fourcc('S', '2', '6', '5') /* HEVC parsed slices */ ++#define V4L2_PIX_FMT_AV1_FRAME v4l2_fourcc('A', 'V', '1', 'F') /* AV1 parsed frame */ + #define V4L2_PIX_FMT_SPK v4l2_fourcc('S', 'P', 'K', '0') /* Sorenson Spark */ + #define V4L2_PIX_FMT_RV30 v4l2_fourcc('R', 'V', '3', '0') /* RealVideo 8 */ + #define V4L2_PIX_FMT_RV40 v4l2_fourcc('R', 'V', '4', '0') /* RealVideo 9 & 10 */ +@@ -1668,7 +1669,7 @@ struct v4l2_input { + __u8 name[32]; /* Label */ + __u32 type; /* Type of input */ + __u32 audioset; /* Associated audios (bitfield) */ +- __u32 tuner; /* enum v4l2_tuner_type */ ++ __u32 tuner; /* Tuner index */ + v4l2_std_id std; + __u32 status; + __u32 capabilities; +@@ -1755,8 +1756,8 @@ struct v4l2_ext_control { + __u8 *p_u8; + __u16 *p_u16; + __u32 *p_u32; +- __u32 *p_s32; +- __u32 *p_s64; ++ __s32 *p_s32; ++ __s64 *p_s64; + struct v4l2_area *p_area; + struct v4l2_ctrl_h264_sps *p_h264_sps; + struct v4l2_ctrl_h264_pps *p_h264_pps; +@@ -1776,6 +1777,10 @@ struct v4l2_ext_control { + struct v4l2_ctrl_hevc_slice_params *p_hevc_slice_params; + struct v4l2_ctrl_hevc_scaling_matrix *p_hevc_scaling_matrix; + struct v4l2_ctrl_hevc_decode_params *p_hevc_decode_params; ++ struct v4l2_ctrl_av1_sequence *p_av1_sequence; ++ struct v4l2_ctrl_av1_tile_group_entry *p_av1_tile_group_entry; ++ struct v4l2_ctrl_av1_frame *p_av1_frame; ++ struct v4l2_ctrl_av1_film_grain *p_av1_film_grain; + void *ptr; + }; + } __attribute__ ((packed)); +@@ -1845,6 +1850,11 @@ enum v4l2_ctrl_type { + V4L2_CTRL_TYPE_HEVC_SLICE_PARAMS = 0x0272, + V4L2_CTRL_TYPE_HEVC_SCALING_MATRIX = 0x0273, + V4L2_CTRL_TYPE_HEVC_DECODE_PARAMS = 0x0274, ++ ++ V4L2_CTRL_TYPE_AV1_SEQUENCE = 0x280, ++ V4L2_CTRL_TYPE_AV1_TILE_GROUP_ENTRY = 0x281, ++ V4L2_CTRL_TYPE_AV1_FRAME = 0x282, ++ V4L2_CTRL_TYPE_AV1_FILM_GRAIN = 0x283, + }; + + /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ +--- a/x86/usr/include/linux/virtio_pmem.h ++++ b/x86/usr/include/linux/virtio_pmem.h +@@ -14,6 +14,13 @@ + #include + #include + ++/* Feature bits */ ++/* guest physical address range will be indicated as shared memory region 0 */ ++#define VIRTIO_PMEM_F_SHMEM_REGION 0 ++ ++/* shmid of the shared memory region corresponding to the pmem */ ++#define VIRTIO_PMEM_SHMEM_REGION_ID 0 ++ + struct virtio_pmem_config { + __le64 start; + __le64 size; +--- a/x86/usr/include/linux/vm_sockets.h ++++ b/x86/usr/include/linux/vm_sockets.h +@@ -189,4 +189,21 @@ struct sockaddr_vm { + + #define IOCTL_VM_SOCKETS_GET_LOCAL_CID _IO(7, 0xb9) + ++/* MSG_ZEROCOPY notifications are encoded in the standard error format, ++ * sock_extended_err. See Documentation/networking/msg_zerocopy.rst in ++ * kernel source tree for more details. ++ */ ++ ++/* 'cmsg_level' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define SOL_VSOCK 287 ++ ++/* 'cmsg_type' field value of 'struct cmsghdr' for notification parsing ++ * when MSG_ZEROCOPY flag is used on transmissions. ++ */ ++ ++#define VSOCK_RECVERR 1 ++ + #endif /* _VM_SOCKETS_H */ +--- a/x86/usr/include/rdma/bnxt_re-abi.h ++++ b/x86/usr/include/rdma/bnxt_re-abi.h +@@ -41,6 +41,7 @@ + #define __BNXT_RE_UVERBS_ABI_H__ + + #include ++#include + + #define BNXT_RE_ABI_VERSION 1 + +@@ -51,6 +52,10 @@ + enum { + BNXT_RE_UCNTX_CMASK_HAVE_CCTX = 0x1ULL, + BNXT_RE_UCNTX_CMASK_HAVE_MODE = 0x02ULL, ++ BNXT_RE_UCNTX_CMASK_WC_DPI_ENABLED = 0x04ULL, ++ BNXT_RE_UCNTX_CMASK_DBR_PACING_ENABLED = 0x08ULL, ++ BNXT_RE_UCNTX_CMASK_POW2_DISABLED = 0x10ULL, ++ BNXT_RE_COMP_MASK_UCNTX_HW_RETX_ENABLED = 0x40, + }; + + enum bnxt_re_wqe_mode { +@@ -59,6 +64,14 @@ enum bnxt_re_wqe_mode { + BNXT_QPLIB_WQE_MODE_INVALID = 0x02, + }; + ++enum { ++ BNXT_RE_COMP_MASK_REQ_UCNTX_POW2_SUPPORT = 0x01, ++}; ++ ++struct bnxt_re_uctx_req { ++ __aligned_u64 comp_mask; ++}; ++ + struct bnxt_re_uctx_resp { + __u32 dev_id; + __u32 max_qp; +@@ -89,11 +102,16 @@ struct bnxt_re_cq_req { + __aligned_u64 cq_handle; + }; + ++enum bnxt_re_cq_mask { ++ BNXT_RE_CQ_TOGGLE_PAGE_SUPPORT = 0x1, ++}; ++ + struct bnxt_re_cq_resp { + __u32 cqid; + __u32 tail; + __u32 phase; + __u32 rsvd; ++ __aligned_u64 comp_mask; + }; + + struct bnxt_re_resize_cq_req { +@@ -127,4 +145,61 @@ enum bnxt_re_shpg_offt { + BNXT_RE_END_RESV_OFFT = 0xFF0 + }; + ++enum bnxt_re_objects { ++ BNXT_RE_OBJECT_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_OBJECT_NOTIFY_DRV, ++ BNXT_RE_OBJECT_GET_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_alloc_page_type { ++ BNXT_RE_ALLOC_WC_PAGE = 0, ++ BNXT_RE_ALLOC_DBR_BAR_PAGE, ++ BNXT_RE_ALLOC_DBR_PAGE, ++}; ++ ++enum bnxt_re_var_alloc_page_attrs { ++ BNXT_RE_ALLOC_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_ALLOC_PAGE_TYPE, ++ BNXT_RE_ALLOC_PAGE_DPI, ++ BNXT_RE_ALLOC_PAGE_MMAP_OFFSET, ++ BNXT_RE_ALLOC_PAGE_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_alloc_page_attrs { ++ BNXT_RE_DESTROY_PAGE_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_alloc_page_methods { ++ BNXT_RE_METHOD_ALLOC_PAGE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_DESTROY_PAGE, ++}; ++ ++enum bnxt_re_notify_drv_methods { ++ BNXT_RE_METHOD_NOTIFY_DRV = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++/* Toggle mem */ ++ ++enum bnxt_re_get_toggle_mem_type { ++ BNXT_RE_CQ_TOGGLE_MEM = 0, ++ BNXT_RE_SRQ_TOGGLE_MEM, ++}; ++ ++enum bnxt_re_var_toggle_mem_attrs { ++ BNXT_RE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_TOGGLE_MEM_TYPE, ++ BNXT_RE_TOGGLE_MEM_RES_ID, ++ BNXT_RE_TOGGLE_MEM_MMAP_PAGE, ++ BNXT_RE_TOGGLE_MEM_MMAP_OFFSET, ++ BNXT_RE_TOGGLE_MEM_MMAP_LENGTH, ++}; ++ ++enum bnxt_re_toggle_mem_attrs { ++ BNXT_RE_RELEASE_TOGGLE_MEM_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ ++enum bnxt_re_toggle_mem_methods { ++ BNXT_RE_METHOD_GET_TOGGLE_MEM = (1U << UVERBS_ID_NS_SHIFT), ++ BNXT_RE_METHOD_RELEASE_TOGGLE_MEM, ++}; + #endif /* __BNXT_RE_UVERBS_ABI_H__*/ +--- a/x86/usr/include/rdma/efa-abi.h ++++ b/x86/usr/include/rdma/efa-abi.h +@@ -1,12 +1,13 @@ + /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ + /* +- * Copyright 2018-2023 Amazon.com, Inc. or its affiliates. All rights reserved. ++ * Copyright 2018-2024 Amazon.com, Inc. or its affiliates. All rights reserved. + */ + + #ifndef EFA_ABI_USER_H + #define EFA_ABI_USER_H + + #include ++#include + + /* + * Increment this value if any changes that break userspace ABI +@@ -134,4 +135,22 @@ struct efa_ibv_ex_query_device_resp { + __u32 device_caps; + }; + ++enum { ++ EFA_QUERY_MR_VALIDITY_RECV_IC_ID = 1 << 0, ++ EFA_QUERY_MR_VALIDITY_RDMA_READ_IC_ID = 1 << 1, ++ EFA_QUERY_MR_VALIDITY_RDMA_RECV_IC_ID = 1 << 2, ++}; ++ ++enum efa_query_mr_attrs { ++ EFA_IB_ATTR_QUERY_MR_HANDLE = (1U << UVERBS_ID_NS_SHIFT), ++ EFA_IB_ATTR_QUERY_MR_RESP_IC_ID_VALIDITY, ++ EFA_IB_ATTR_QUERY_MR_RESP_RECV_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_READ_IC_ID, ++ EFA_IB_ATTR_QUERY_MR_RESP_RDMA_RECV_IC_ID, ++}; ++ ++enum efa_mr_methods { ++ EFA_IB_METHOD_MR_QUERY = (1U << UVERBS_ID_NS_SHIFT), ++}; ++ + #endif /* EFA_ABI_USER_H */ +--- a/x86/usr/include/rdma/hns-abi.h ++++ b/x86/usr/include/rdma/hns-abi.h +@@ -52,15 +52,25 @@ struct hns_roce_ib_create_cq_resp { + __aligned_u64 cap_flags; + }; + ++enum hns_roce_srq_cap_flags { ++ HNS_ROCE_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ ++enum hns_roce_srq_cap_flags_resp { ++ HNS_ROCE_RSP_SRQ_CAP_RECORD_DB = 1 << 0, ++}; ++ + struct hns_roce_ib_create_srq { + __aligned_u64 buf_addr; + __aligned_u64 db_addr; + __aligned_u64 que_addr; ++ __u32 req_cap_flags; /* Use enum hns_roce_srq_cap_flags */ ++ __u32 reserved; + }; + + struct hns_roce_ib_create_srq_resp { + __u32 srqn; +- __u32 reserved; ++ __u32 cap_flags; /* Use enum hns_roce_srq_cap_flags */ + }; + + struct hns_roce_ib_create_qp { +@@ -115,4 +125,9 @@ struct hns_roce_ib_alloc_pd_resp { + __u32 pdn; + }; + ++struct hns_roce_ib_create_ah_resp { ++ __u8 dmac[6]; ++ __u8 reserved[2]; ++}; ++ + #endif /* HNS_ABI_USER_H */ +--- a/x86/usr/include/rdma/ib_user_ioctl_verbs.h ++++ b/x86/usr/include/rdma/ib_user_ioctl_verbs.h +@@ -220,7 +220,8 @@ enum ib_uverbs_advise_mr_flag { + struct ib_uverbs_query_port_resp_ex { + struct ib_uverbs_query_port_resp legacy_resp; + __u16 port_cap_flags2; +- __u8 reserved[6]; ++ __u8 reserved[2]; ++ __u32 active_speed_ex; + }; + + struct ib_uverbs_qp_cap { +--- a/x86/usr/include/rdma/irdma-abi.h ++++ b/x86/usr/include/rdma/irdma-abi.h +@@ -22,10 +22,16 @@ enum irdma_memreg_type { + IRDMA_MEMREG_TYPE_CQ = 2, + }; + ++enum { ++ IRDMA_ALLOC_UCTX_USE_RAW_ATTR = 1 << 0, ++ IRDMA_ALLOC_UCTX_MIN_HW_WQ_SIZE = 1 << 1, ++}; ++ + struct irdma_alloc_ucontext_req { + __u32 rsvd32; + __u8 userspace_ver; + __u8 rsvd8[3]; ++ __aligned_u64 comp_mask; + }; + + struct irdma_alloc_ucontext_resp { +@@ -46,6 +52,9 @@ struct irdma_alloc_ucontext_resp { + __u16 max_hw_sq_chunk; + __u8 hw_rev; + __u8 rsvd2; ++ __aligned_u64 comp_mask; ++ __u16 min_hw_wq_size; ++ __u8 rsvd3[6]; + }; + + struct irdma_alloc_pd_resp { +--- a/x86/usr/include/rdma/mlx5-abi.h ++++ b/x86/usr/include/rdma/mlx5-abi.h +@@ -37,6 +37,7 @@ + #include + #include /* For ETH_ALEN. */ + #include ++#include + + enum { + MLX5_QP_FLAG_SIGNATURE = 1 << 0, +@@ -275,6 +276,7 @@ struct mlx5_ib_query_device_resp { + __u32 tunnel_offloads_caps; /* enum mlx5_ib_tunnel_offloads */ + struct mlx5_ib_dci_streams_caps dci_streams_caps; + __u16 reserved; ++ struct mlx5_ib_uapi_reg reg_c0; + }; + + enum mlx5_ib_create_cq_flags { +--- a/x86/usr/include/rdma/mlx5_user_ioctl_verbs.h ++++ b/x86/usr/include/rdma/mlx5_user_ioctl_verbs.h +@@ -64,6 +64,7 @@ enum mlx5_ib_uapi_dm_type { + MLX5_IB_UAPI_DM_TYPE_STEERING_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_SW_ICM, + MLX5_IB_UAPI_DM_TYPE_HEADER_MODIFY_PATTERN_SW_ICM, ++ MLX5_IB_UAPI_DM_TYPE_ENCAP_SW_ICM, + }; + + enum mlx5_ib_uapi_devx_create_event_channel_flags { +--- a/x86/usr/include/rdma/rdma_netlink.h ++++ b/x86/usr/include/rdma/rdma_netlink.h +@@ -299,6 +299,8 @@ enum rdma_nldev_command { + + RDMA_NLDEV_CMD_STAT_GET_STATUS, + ++ RDMA_NLDEV_CMD_RES_SRQ_GET_RAW, ++ + RDMA_NLDEV_NUM_OPS + }; + +@@ -554,6 +556,8 @@ enum rdma_nldev_attr { + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_INDEX, /* u32 */ + RDMA_NLDEV_ATTR_STAT_HWCOUNTER_DYNAMIC, /* u8 */ + ++ RDMA_NLDEV_SYS_ATTR_PRIVILEGED_QKEY_MODE, /* u8 */ ++ + /* + * Always the end + */ +--- a/x86/usr/include/rdma/siw-abi.h ++++ b/x86/usr/include/rdma/siw-abi.h +@@ -1,4 +1,4 @@ +-/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) or BSD-3-Clause */ ++/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause */ + + /* Authors: Bernard Metzler */ + /* Copyright (c) 2008-2019, IBM Corporation */ +--- a/x86/usr/include/scsi/scsi_bsg_mpi3mr.h ++++ b/x86/usr/include/scsi/scsi_bsg_mpi3mr.h +@@ -491,6 +491,8 @@ struct mpi3_nvme_encapsulated_error_repl + #define MPI3MR_NVME_DATA_FORMAT_PRP 0 + #define MPI3MR_NVME_DATA_FORMAT_SGL1 1 + #define MPI3MR_NVME_DATA_FORMAT_SGL2 2 ++#define MPI3MR_NVMESGL_DATA_SEGMENT 0x00 ++#define MPI3MR_NVMESGL_LAST_SEGMENT 0x03 + + /* MPI3: task management related definitions */ + struct mpi3_scsi_task_mgmt_request { +--- a/x86/usr/include/sound/asequencer.h ++++ b/x86/usr/include/sound/asequencer.h +@@ -10,7 +10,7 @@ + #include + + /** version of the sequencer */ +-#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2) ++#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 3) + + /** + * definition of sequencer event types +@@ -174,6 +174,7 @@ struct snd_seq_connect { + #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) /* event should be processed before others */ + #define SNDRV_SEQ_PRIORITY_MASK (1<<4) + ++#define SNDRV_SEQ_EVENT_UMP (1<<5) /* event holds a UMP packet */ + + /* note event */ + struct snd_seq_ev_note { +@@ -252,6 +253,19 @@ struct snd_seq_ev_quote { + struct snd_seq_event *event; /* quoted event */ + } __attribute__((packed)); + ++union snd_seq_event_data { /* event data... */ ++ struct snd_seq_ev_note note; ++ struct snd_seq_ev_ctrl control; ++ struct snd_seq_ev_raw8 raw8; ++ struct snd_seq_ev_raw32 raw32; ++ struct snd_seq_ev_ext ext; ++ struct snd_seq_ev_queue_control queue; ++ union snd_seq_timestamp time; ++ struct snd_seq_addr addr; ++ struct snd_seq_connect connect; ++ struct snd_seq_result result; ++ struct snd_seq_ev_quote quote; ++}; + + /* sequencer event */ + struct snd_seq_event { +@@ -262,25 +276,27 @@ struct snd_seq_event { + unsigned char queue; /* schedule queue */ + union snd_seq_timestamp time; /* schedule time */ + +- + struct snd_seq_addr source; /* source address */ + struct snd_seq_addr dest; /* destination address */ + +- union { /* event data... */ +- struct snd_seq_ev_note note; +- struct snd_seq_ev_ctrl control; +- struct snd_seq_ev_raw8 raw8; +- struct snd_seq_ev_raw32 raw32; +- struct snd_seq_ev_ext ext; +- struct snd_seq_ev_queue_control queue; +- union snd_seq_timestamp time; +- struct snd_seq_addr addr; +- struct snd_seq_connect connect; +- struct snd_seq_result result; +- struct snd_seq_ev_quote quote; +- } data; ++ union snd_seq_event_data data; + }; + ++ /* (compatible) event for UMP-capable clients */ ++struct snd_seq_ump_event { ++ snd_seq_event_type_t type; /* event type */ ++ unsigned char flags; /* event flags */ ++ char tag; ++ unsigned char queue; /* schedule queue */ ++ union snd_seq_timestamp time; /* schedule time */ ++ struct snd_seq_addr source; /* source address */ ++ struct snd_seq_addr dest; /* destination address */ ++ ++ union { ++ union snd_seq_event_data data; ++ unsigned int ump[4]; ++ }; ++}; + + /* + * bounce event - stored as variable size data +@@ -331,6 +347,7 @@ typedef int __bitwise snd_seq_client_typ + #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) /* accept broadcast messages */ + #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) /* accept multicast messages */ + #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) /* accept bounce event in error */ ++#define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) /* don't convert UMP events */ + #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) /* use event filter */ + + struct snd_seq_client_info { +@@ -344,9 +361,18 @@ struct snd_seq_client_info { + int event_lost; /* number of lost events */ + int card; /* RO: card number[kernel] */ + int pid; /* RO: pid[user] */ +- char reserved[56]; /* for future use */ ++ unsigned int midi_version; /* MIDI version */ ++ unsigned int group_filter; /* UMP group filter bitmap ++ * (bit 0 = groupless messages, ++ * bit 1-16 = messages for groups 1-16) ++ */ ++ char reserved[48]; /* for future use */ + }; + ++/* MIDI version numbers in client info */ ++#define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 /* Legacy client */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 /* UMP MIDI 1.0 */ ++#define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 /* UMP MIDI 2.0 */ + + /* client pool size */ + struct snd_seq_client_pool { +@@ -406,6 +432,8 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) /* allow read subscription */ + #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) /* allow write subscription */ + #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) /* routing not allowed */ ++#define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) /* inactive port */ ++#define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) /* MIDI 2.0 UMP Endpoint port */ + + /* port type */ + #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) /* hardware specific */ +@@ -415,6 +443,7 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) /* XG compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) /* MT-32 compatible device */ + #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) /* General MIDI 2 compatible device */ ++#define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) /* UMP */ + + /* other standards...*/ + #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) /* Synth device (no MIDI compatible - direct wavetable) */ +@@ -432,6 +461,12 @@ struct snd_seq_remove_events { + #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) + #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) + ++/* port direction */ ++#define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 ++#define SNDRV_SEQ_PORT_DIR_INPUT 1 ++#define SNDRV_SEQ_PORT_DIR_OUTPUT 2 ++#define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 ++ + struct snd_seq_port_info { + struct snd_seq_addr addr; /* client/port numbers */ + char name[64]; /* port name */ +@@ -448,7 +483,9 @@ struct snd_seq_port_info { + void *kernel; /* reserved for kernel use (must be NULL) */ + unsigned int flags; /* misc. conditioning */ + unsigned char time_queue; /* queue # for timestamping */ +- char reserved[59]; /* for future use */ ++ unsigned char direction; /* port usage direction (r/w/bidir) */ ++ unsigned char ump_group; /* 0 = UMP EP (no conversion), 1-16 = UMP group number */ ++ char reserved[57]; /* for future use */ + }; + + +@@ -552,6 +589,18 @@ struct snd_seq_query_subs { + char reserved[64]; /* for future use */ + }; + ++/* ++ * UMP-specific information ++ */ ++/* type of UMP info query */ ++#define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 ++#define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 ++ ++struct snd_seq_client_ump_info { ++ int client; /* client number to inquire/set */ ++ int type; /* type to inquire/set */ ++ unsigned char info[512]; /* info (either UMP ep or block info) */ ++} __attribute__((packed)); + + /* + * IOCTL commands +@@ -561,9 +610,12 @@ struct snd_seq_query_subs { + #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) + #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) + #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) ++#define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) + + #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) + #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) ++#define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) ++#define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) + + #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) + #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) +--- a/x86/usr/include/sound/asound.h ++++ b/x86/usr/include/sound/asound.h +@@ -272,6 +272,7 @@ typedef int __bitwise snd_pcm_subformat_ + #define SNDRV_PCM_INFO_DOUBLE 0x00000004 /* Double buffering needed for PCM start/stop */ + #define SNDRV_PCM_INFO_BATCH 0x00000010 /* double buffering */ + #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 /* need the explicit sync of appl_ptr update */ ++#define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 /* silencing at the end of stream is not required */ + #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 /* channels are interleaved */ + #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 /* channels are not interleaved */ + #define SNDRV_PCM_INFO_COMPLEX 0x00000400 /* complex frame organization (mmap only) */ +@@ -381,6 +382,9 @@ typedef int snd_pcm_hw_param_t; + #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) /* avoid rate resampling */ + #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) /* export buffer */ + #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) /* disable period wakeups */ ++#define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) /* suppress drain with the filling ++ * of the silence samples ++ */ + + struct snd_interval { + unsigned int min, max; +@@ -700,7 +704,7 @@ enum { + * Raw MIDI section - /dev/snd/midi?? + */ + +-#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 2) ++#define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 4) + + enum { + SNDRV_RAWMIDI_STREAM_OUTPUT = 0, +@@ -711,6 +715,7 @@ enum { + #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 + #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 + #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 ++#define SNDRV_RAWMIDI_INFO_UMP 0x00000008 + + struct snd_rawmidi_info { + unsigned int device; /* RO/WR (control): device number */ +@@ -769,6 +774,72 @@ struct snd_rawmidi_status { + unsigned char reserved[16]; /* reserved for future use */ + }; + ++/* UMP EP info flags */ ++#define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 ++ ++/* UMP EP Protocol / JRTS capability bits */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 /* MIDI 1.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 /* MIDI 2.0 */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 /* JRTS Transmit */ ++#define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 /* JRTS Receive */ ++ ++/* UMP Endpoint information */ ++struct snd_ump_endpoint_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned int flags; /* additional info */ ++ unsigned int protocol_caps; /* protocol capabilities */ ++ unsigned int protocol; /* current protocol */ ++ unsigned int num_blocks; /* # of function blocks */ ++ unsigned short version; /* UMP major/minor version */ ++ unsigned short family_id; /* MIDI device family ID */ ++ unsigned short model_id; /* MIDI family model ID */ ++ unsigned int manufacturer_id; /* MIDI manufacturer ID */ ++ unsigned char sw_revision[4]; /* software revision */ ++ unsigned short padding; ++ unsigned char name[128]; /* endpoint name string */ ++ unsigned char product_id[128]; /* unique product id string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ ++/* UMP direction */ ++#define SNDRV_UMP_DIR_INPUT 0x01 ++#define SNDRV_UMP_DIR_OUTPUT 0x02 ++#define SNDRV_UMP_DIR_BIDIRECTION 0x03 ++ ++/* UMP block info flags */ ++#define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) /* MIDI 1.0 port w/o restrict */ ++#define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) /* 31.25Kbps B/W MIDI1 port */ ++ ++/* UMP block user-interface hint */ ++#define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 ++#define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 ++#define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 ++#define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 ++ ++/* UMP groups and blocks */ ++#define SNDRV_UMP_MAX_GROUPS 16 ++#define SNDRV_UMP_MAX_BLOCKS 32 ++ ++/* UMP Block information */ ++struct snd_ump_block_info { ++ int card; /* card number */ ++ int device; /* device number */ ++ unsigned char block_id; /* block ID (R/W) */ ++ unsigned char direction; /* UMP direction */ ++ unsigned char active; /* Activeness */ ++ unsigned char first_group; /* first group ID */ ++ unsigned char num_groups; /* number of groups */ ++ unsigned char midi_ci_version; /* MIDI-CI support version */ ++ unsigned char sysex8_streams; /* max number of sysex8 streams */ ++ unsigned char ui_hint; /* user interface hint */ ++ unsigned int flags; /* various info flags */ ++ unsigned char name[128]; /* block name string */ ++ unsigned char reserved[32]; ++} __attribute__((packed)); ++ + #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) + #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) + #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) +@@ -776,6 +847,9 @@ struct snd_rawmidi_status { + #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) + #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) + #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) ++/* Additional ioctls for UMP rawmidi devices */ ++#define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) ++#define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) + + /* + * Timer section - /dev/snd/timer +@@ -947,7 +1021,7 @@ struct snd_timer_tread { + * * + ****************************************************************************/ + +-#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) ++#define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) + + struct snd_ctl_card_info { + int card; /* card number */ +@@ -1108,6 +1182,9 @@ struct snd_ctl_tlv { + #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) + #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) + #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) ++#define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) ++#define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) ++#define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) + #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) + #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) + +--- a/x86/usr/include/sound/sof/tokens.h ++++ b/x86/usr/include/sound/sof/tokens.h +@@ -99,7 +99,11 @@ + #define SOF_TKN_COMP_OUTPUT_PIN_BINDING_WNAME 414 + #define SOF_TKN_COMP_NUM_INPUT_AUDIO_FORMATS 415 + #define SOF_TKN_COMP_NUM_OUTPUT_AUDIO_FORMATS 416 +- ++/* ++ * The token value is copied to the dapm_widget's ++ * no_wname_in_kcontrol_name. ++ */ ++#define SOF_TKN_COMP_NO_WNAME_IN_KCONTROL_NAME 417 + + /* SSP */ + #define SOF_TKN_INTEL_SSP_CLKS_CONTROL 500 diff --git a/linux-glibc-devel.changes b/linux-glibc-devel.changes index 0dbe042..40c3ed2 100644 --- a/linux-glibc-devel.changes +++ b/linux-glibc-devel.changes @@ -1,3 +1,32 @@ +------------------------------------------------------------------- +Mon Feb 5 16:21:33 UTC 2024 - Takashi Iwai + +- Sync with the latest SLE15-SP6 kernel, as of commit 3a5699ce2499 + (bsc#1217465): linux-glibc-devel-current.patch + * EFI update (fate#316350) + * amd/amdkfd updates (jsc#PED-3527 jsc#PED-5475 jsc#PED-6068 jsc#PED-6070 jsc#PED-6116 jsc#PED-6120 jsc#PED-5065 jsc#PED-5477 jsc#PED-5511 jsc#PED-6041 jsc#PED-6069 jsc#PED-6071) + * Sound updates (jsc#PED-6045 jsc#PED-6036 jsc#PED-6104 jsc#PED-6114 jsc#PED-6067 jsc#PED-6123) + * UAPI fixes (bsc#1217382) + * IB updates (jsc#PED-6864) + * KVM s390 updates (jsc#PED-5441) + * RDMA updates (jsc#PED-7574 jsc#PED-6864) + * Block updates (bsc#1012628 jsc#PED-3545 bsc#1216436 bsc#1216435 bsc#1218003) + * BPF updates (jsc#PED-6811) + * virtual/devlink updates (jsc#PED-3311 jsc#PED-7785 jsc#PED-5853 jsc#PED-5505) + * DPLL updates (jsc#PED-6079) + * FUSE fix (bsc#1012628) + * io_uring updates (bsc#1215211) + * MD fix (bnc#763402) + * Media fixes (bsc#1012628) + * Net updates (jsc#PED-4876 jsc#PED-4860 jsc#PED-6079 jsc#PED-7574) + * perf updates (jsc#PED-6012 jsc#PED-6121) + * Arm64 updates (jsc#PED-5458) + * PowerPC updates (jsc#PED-4486 jsc#PED-5452) + * S390 updates (jsc#PED-6371 jsc#PED-3289 jsc#PED-5417 bsc#1218992) + * X86 updates (jsc#PED-6018 bsc#1216611) + * WiFi updates (jsc#PED-6081 jsc#PED-6130) +- Add scripts to create a patch from kernel-source git tree + ------------------------------------------------------------------- Mon Jun 26 08:03:11 UTC 2023 - Andreas Schwab diff --git a/linux-glibc-devel.spec b/linux-glibc-devel.spec index 9891e7d..c9e9670 100644 --- a/linux-glibc-devel.spec +++ b/linux-glibc-devel.spec @@ -25,6 +25,9 @@ Group: Development/Libraries/C and C++ URL: http://www.kernel.org/ Source: %{name}-%{version}.tar.xz Source1: install_all.sh +Source2: make_diff.sh +Source3: cleanup_patch.sh +Patch1: %{name}-current.patch BuildRequires: xz # rpm-build requires gettext-tools; ignore this, in order to shorten cycles (we have no translations) #!BuildIgnore: gettext-tools @@ -95,6 +98,7 @@ required for compilation of almost all programs. %prep %setup -q -n linux-glibc-devel-%{version} +%patch1 -p1 %build for karch in *; do diff --git a/make_diff.sh b/make_diff.sh new file mode 100644 index 0000000..d124c76 --- /dev/null +++ b/make_diff.sh @@ -0,0 +1,97 @@ +#!/bin/bash +# +# Create a patch file between the base version and the current kernel-source +# Run on kernel-source.git repository: +# % make_diff.sh /somewhere/linux-glibc-devel-6.4.tar.xz +# + +set -e + +if [ -z "$1" ]; then + echo "usage: make_diff.sh base-tarball [patchfile]" + exit 1 +fi + +base="$1" +case "$base" in + */linux-glibc-devel-*.tar.*) + ;; + *) + echo "Invalid base tarball $1" + exit 1;; +esac +if [ ! -f "$base" ]; then + echo "Invalid base tarball $base" + exit 1 +fi +basever=${base##*/} +basever=${basever%.tar.*} + +test -z "$SCRATCH_AREA" && export SCRATCH_AREA=/dev/shm/scratch +mkdir -p $SCRATCH_AREA +destdir="$SCRATCH_AREA/linux-glibc-devel" + +patchfile="$2" +test -z "$patchfile" && patchfile=linux-glibc-devel-current.patch +case "$patchfile" in + /*) + ;; + *) + patchfile="$PWD/$patchfile";; +esac + +susecommit=$(git rev-parse HEAD) +scripts/sequence-patch.sh --rapid --patch-dir "$destdir" || exit 1 + +cd "$destdir" || exit 1 +kernel_dir="$PWD" +header_dir="$PWD/linux-glibc-devel-current" +mkdir -p "$header_dir" +remove="arc csky h8300 hexagon microblaze nds32 nios2 openrisc sh xtensa um" +archs=$(cd "$kernel_dir/arch" && + for arch in *; do + test -d $arch || continue + case " $remove " in *" $arch "*) continue;; esac + echo $arch + done) +pushd "$kernel_dir" +for arch in $archs; do + mkdir "$header_dir/$arch" + cp Makefile "$header_dir/$arch" + make O="$header_dir/$arch" headers_install ARCH=$arch +done +popd +pushd "$header_dir" +find -type f \( -name ".*.cmd" -o -name Makefile \) -exec rm -f {} + +for arch in $archs; do + cd $arch + #------------------------------------------------------------------- + #Fri Sep 5 10:43:49 CEST 2008 - matz@suse.de + + #- Remove the kernel version of drm headers, they conflict + # with the libdrm ones, and those are slightly newer. + # + rm -rf usr/include/drm/ + # Remove confusing empty uapi directory + test ! -d usr/include/uapi || rmdir usr/include/uapi + for dir in *; do + case "$dir" in + usr) ;; + *) + if test -d "$dir"; then + rm -rf "$dir" + fi + ;; + esac + done + cd .. +done +popd + +tar xf "$base" +echo "kernel-source.git: $susecommit" > "$patchfile" +echo >> "$patchfile" + +diff -ruN "$basever" linux-glibc-devel-current >> "$patchfile" + +exit 0