diff --git a/poky/meta/classes/buildhistory.bbclass b/poky/meta/classes/buildhistory.bbclass
index eb72955..a4288ef 100644
--- a/poky/meta/classes/buildhistory.bbclass
+++ b/poky/meta/classes/buildhistory.bbclass
@@ -113,6 +113,7 @@
             self.packages = ""
             self.srcrev = ""
             self.layer = ""
+            self.config = ""
 
 
     class PackageInfo:
@@ -254,6 +255,7 @@
     rcpinfo.depends = sortlist(oe.utils.squashspaces(d.getVar('DEPENDS') or ""))
     rcpinfo.packages = packages
     rcpinfo.layer = layer
+    rcpinfo.config = sortlist(oe.utils.squashspaces(d.getVar('PACKAGECONFIG') or ""))
     write_recipehistory(rcpinfo, d)
 
     pkgdest = d.getVar('PKGDEST')
@@ -368,6 +370,7 @@
         f.write(u"DEPENDS = %s\n" %  rcpinfo.depends)
         f.write(u"PACKAGES = %s\n" %  rcpinfo.packages)
         f.write(u"LAYER = %s\n" %  rcpinfo.layer)
+        f.write(u"CONFIG = %s\n" %  rcpinfo.config)
 
     write_latest_srcrev(d, pkghistdir)
 
diff --git a/poky/meta/classes/buildstats.bbclass b/poky/meta/classes/buildstats.bbclass
index 2590c60..6f87187 100644
--- a/poky/meta/classes/buildstats.bbclass
+++ b/poky/meta/classes/buildstats.bbclass
@@ -80,8 +80,6 @@
     return timediff, cpuperc
 
 def write_task_data(status, logfile, e, d):
-    bn = d.getVar('BUILDNAME')
-    bsdir = os.path.join(d.getVar('BUILDSTATS_BASE'), bn)
     with open(os.path.join(logfile), "a") as f:
         elapsedtime = get_timedata("__timedata_task", d, e.time)
         if elapsedtime:
@@ -138,7 +136,7 @@
                 if x:
                     f.write(x + " ")
             f.write("\n")
-            f.write("Build Started: %0.2f \n" % time.time())
+            f.write("Build Started: %0.2f \n" % d.getVar('__timedata_build', False)[0])
 
     elif isinstance(e, bb.event.BuildCompleted):
         build_time = os.path.join(bsdir, "build_stats")
diff --git a/poky/meta/classes/cve-check.bbclass b/poky/meta/classes/cve-check.bbclass
index 556ac6e..514897e 100644
--- a/poky/meta/classes/cve-check.bbclass
+++ b/poky/meta/classes/cve-check.bbclass
@@ -301,7 +301,7 @@
 
     for cve in sorted(cve_data):
         write_string += "PACKAGE NAME: %s\n" % d.getVar("PN")
-        write_string += "PACKAGE VERSION: %s\n" % d.getVar("PV")
+        write_string += "PACKAGE VERSION: %s%s\n" % (d.getVar("EXTENDPE"), d.getVar("PV"))
         write_string += "CVE: %s\n" % cve
         if cve in whitelisted:
             write_string += "CVE STATUS: Whitelisted\n"
diff --git a/poky/meta/classes/sstate.bbclass b/poky/meta/classes/sstate.bbclass
index aa9c30b..375196e 100644
--- a/poky/meta/classes/sstate.bbclass
+++ b/poky/meta/classes/sstate.bbclass
@@ -355,6 +355,9 @@
     d.setVar('SSTATE_INSTDIR', sstateinst)
 
     if bb.utils.to_boolean(d.getVar("SSTATE_VERIFY_SIG"), False):
+        if not os.path.isfile(sstatepkg + '.sig'):
+            bb.warn("No signature file for sstate package %s, skipping acceleration..." % sstatepkg)
+            return False
         signer = get_signer(d, 'local')
         if not signer.verify(sstatepkg + '.sig'):
             bb.warn("Cannot verify signature on sstate package %s, skipping acceleration..." % sstatepkg)
@@ -733,10 +736,11 @@
         localdata.setVar('SRC_URI', srcuri)
         try:
             fetcher = bb.fetch2.Fetch([srcuri], localdata, cache=False)
+            fetcher.checkstatus()
             fetcher.download()
 
         except bb.fetch2.BBFetchException:
-            break
+            pass
 
 def sstate_setscene(d):
     shared_state = sstate_state_fromvars(d)
diff --git a/poky/meta/conf/bitbake.conf b/poky/meta/conf/bitbake.conf
index f7700f1..9336c24 100644
--- a/poky/meta/conf/bitbake.conf
+++ b/poky/meta/conf/bitbake.conf
@@ -410,7 +410,6 @@
 DEPLOY_DIR_RPM = "${DEPLOY_DIR}/rpm"
 DEPLOY_DIR_DEB = "${DEPLOY_DIR}/deb"
 DEPLOY_DIR_IMAGE ?= "${DEPLOY_DIR}/images/${MACHINE}"
-DEPLOY_DIR_TOOLS = "${DEPLOY_DIR}/tools"
 
 PKGDATA_DIR = "${TMPDIR}/pkgdata/${MACHINE}"
 
diff --git a/poky/meta/conf/distro/include/maintainers.inc b/poky/meta/conf/distro/include/maintainers.inc
index 51e6da6..6496a48 100644
--- a/poky/meta/conf/distro/include/maintainers.inc
+++ b/poky/meta/conf/distro/include/maintainers.inc
@@ -28,9 +28,9 @@
 # Please keep this list in alphabetical order.
 #
 RECIPE_MAINTAINER_pn-acl = "Chen Qi <Qi.Chen@windriver.com>"
-RECIPE_MAINTAINER_pn-acpica = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-acpid = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-adwaita-icon-theme = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-acpica = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-acpid = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-adwaita-icon-theme = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-alsa-lib = "Tanu Kaskinen <tanuk@iki.fi>"
 RECIPE_MAINTAINER_pn-alsa-plugins = "Tanu Kaskinen <tanuk@iki.fi>"
 RECIPE_MAINTAINER_pn-alsa-state = "Tanu Kaskinen <tanuk@iki.fi>"
@@ -43,7 +43,6 @@
 RECIPE_MAINTAINER_pn-apr = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-apr-util = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-apt = "Aníbal Limón <limon.anibal@gmail.com>"
-RECIPE_MAINTAINER_pn-apt-native = "Aníbal Limón <limon.anibal@gmail.com>"
 RECIPE_MAINTAINER_pn-argp-standalone = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-asciidoc = "Yi Zhao <yi.zhao@windriver.com>"
 RECIPE_MAINTAINER_pn-aspell = "Anuj Mittal <anuj.mittal@intel.com>"
@@ -95,15 +94,15 @@
 RECIPE_MAINTAINER_pn-ccache = "Robert Yang <liezhi.yang@windriver.com>"
 RECIPE_MAINTAINER_pn-cdrtools-native = "Yi Zhao <yi.zhao@windriver.com>"
 RECIPE_MAINTAINER_pn-chrpath = "Yi Zhao <yi.zhao@windriver.com>"
-RECIPE_MAINTAINER_pn-clutter-1.0 = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-clutter-gst-3.0 = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-clutter-gtk-1.0 = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-clutter-1.0 = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-clutter-gst-3.0 = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-clutter-gtk-1.0 = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-cmake = "Pascal Bach <pascal.bach@siemens.com>"
 RECIPE_MAINTAINER_pn-cmake-native = "Pascal Bach <pascal.bach@siemens.com>"
-RECIPE_MAINTAINER_pn-cogl-1.0 = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-cogl-1.0 = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-connman = "Changhyeok Bae <changhyeok.bae@gmail.com>"
-RECIPE_MAINTAINER_pn-connman-conf = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-connman-gnome = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-connman-conf = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-connman-gnome = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-consolekit = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-core-image-base = "Richard Purdie <richard.purdie@linuxfoundation.org>"
 RECIPE_MAINTAINER_pn-core-image-minimal = "Richard Purdie <richard.purdie@linuxfoundation.org>"
@@ -134,8 +133,8 @@
 RECIPE_MAINTAINER_pn-cryptodev-tests = "Robert Yang <liezhi.yang@windriver.com>"
 RECIPE_MAINTAINER_pn-cups = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-curl = "Armin Kuster <akuster808@gmail.com>"
-RECIPE_MAINTAINER_pn-cve-update-db-native = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-cwautomacros = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-cve-update-db-native = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-cwautomacros = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-db = "Mark Hatle <mark.hatle@windriver.com>"
 RECIPE_MAINTAINER_pn-dbus = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-dbus-glib = "Chen Qi <Qi.Chen@windriver.com>"
@@ -163,8 +162,8 @@
 RECIPE_MAINTAINER_pn-dwarfsrcfiles = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-e2fsprogs = "Robert Yang <liezhi.yang@windriver.com>"
 RECIPE_MAINTAINER_pn-ed = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-efivar = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-efibootmgr = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-efivar = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-efibootmgr = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-elfutils = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-ell = "Oleksandr Kravchuk <open.source@oleksandr-kravchuk.com>"
 RECIPE_MAINTAINER_pn-enchant2 = "Anuj Mittal <anuj.mittal@intel.com>"
@@ -181,10 +180,10 @@
 RECIPE_MAINTAINER_pn-flex = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-font-alias = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-font-util = "Armin Kuster <akuster808@gmail.com>"
-RECIPE_MAINTAINER_pn-fontconfig = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-formfactor = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-freetype = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-fribidi = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-fontconfig = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-formfactor = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-freetype = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-fribidi = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-fts = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-gawk = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-gcc = "Khem Raj <raj.khem@gmail.com>"
@@ -194,13 +193,13 @@
 RECIPE_MAINTAINER_pn-gcc-runtime = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-gcc-sanitizers = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-gcc-source-10.1.0 = "Khem Raj <raj.khem@gmail.com>"
-RECIPE_MAINTAINER_pn-gconf = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-gconf = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-gcr = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-gdb = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-gdb-cross-${TARGET_ARCH} = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-gdb-cross-canadian-${TRANSLATED_TARGET_ARCH} = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-gdbm = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-gdk-pixbuf = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-gdk-pixbuf = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-gettext = "Robert Yang <liezhi.yang@windriver.com>"
 RECIPE_MAINTAINER_pn-gettext-minimal-native = "Robert Yang <liezhi.yang@windriver.com>"
 RECIPE_MAINTAINER_pn-ghostscript = "Hongxu Jia <hongxu.jia@windriver.com>"
@@ -215,7 +214,7 @@
 RECIPE_MAINTAINER_pn-glibc-testsuite = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-glide = "Otavio Salvador <otavio.salvador@ossystems.com.br>"
 RECIPE_MAINTAINER_pn-gmp = "Khem Raj <raj.khem@gmail.com>"
-RECIPE_MAINTAINER_pn-gnome-desktop-testing = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-gnome-desktop-testing = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-gnu-config = "Robert Yang <liezhi.yang@windriver.com>"
 RECIPE_MAINTAINER_pn-gnu-efi = "Yi Zhao <yi.zhao@windriver.com>"
 RECIPE_MAINTAINER_pn-gnupg = "Hongxu Jia <hongxu.jia@windriver.com>"
@@ -251,7 +250,7 @@
 RECIPE_MAINTAINER_pn-gstreamer1.0-python = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-gstreamer1.0-rtsp-server = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-gstreamer1.0-vaapi = "Anuj Mittal <anuj.mittal@intel.com>"
-RECIPE_MAINTAINER_pn-gtk+3 = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-gtk+3 = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-gtk-doc = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-gzip = "Denys Dmytriyenko <denys@ti.com>"
 RECIPE_MAINTAINER_pn-harfbuzz = "Anuj Mittal <anuj.mittal@intel.com>"
@@ -265,6 +264,7 @@
 RECIPE_MAINTAINER_pn-ifupdown = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-inetutils = "Tom Rini <trini@konsulko.com>"
 RECIPE_MAINTAINER_pn-init-ifupdown = "Anuj Mittal <anuj.mittal@intel.com>"
+RECIPE_MAINTAINER_pn-init-system-helpers = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-initramfs-boot = "Otavio Salvador <otavio.salvador@ossystems.com.br>"
 RECIPE_MAINTAINER_pn-initramfs-framework = "Otavio Salvador <otavio.salvador@ossystems.com.br>"
 RECIPE_MAINTAINER_pn-initramfs-live-boot = "Anuj Mittal <anuj.mittal@intel.com>"
@@ -334,18 +334,18 @@
 RECIPE_MAINTAINER_pn-libgcrypt = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-libgfortran = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-libgloss = "Alejandro Hernandez <aehs29@gmail.com>"
-RECIPE_MAINTAINER_pn-libglu = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-libglu = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-libgpg-error = "Hongxu Jia <hongxu.jia@windriver.com>"
-RECIPE_MAINTAINER_pn-libgudev = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-libgudev = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-libhandy = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-libical = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-libical = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-libice = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-libid3tag = "Tanu Kaskinen <tanuk@iki.fi>"
-RECIPE_MAINTAINER_pn-libidn2 = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-libinput = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-libjitterentropy = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-libidn2 = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-libinput = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-libjitterentropy = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-libksba = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-libmatchbox = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-libmatchbox = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-libmnl = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-libmpc = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-libmodule-build-perl = "Tim Orling <timothy.t.orling@linux.intel.com>"
@@ -450,7 +450,7 @@
 RECIPE_MAINTAINER_pn-logrotate = "Yi Zhao <yi.zhao@windriver.com>"
 RECIPE_MAINTAINER_pn-lrzsz = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-lsb-release = "Hongxu Jia <hongxu.jia@windriver.com>"
-RECIPE_MAINTAINER_pn-lsof = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-lsof = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-ltp = "Yi Zhao <yi.zhao@windriver.com>"
 RECIPE_MAINTAINER_pn-lttng-modules = "Richard Purdie <richard.purdie@linuxfoundation.org>"
 RECIPE_MAINTAINER_pn-lttng-tools = "Richard Purdie <richard.purdie@linuxfoundation.org>"
@@ -467,18 +467,18 @@
 RECIPE_MAINTAINER_pn-make-mod-scripts = "Bruce Ashfield <bruce.ashfield@gmail.com>"
 RECIPE_MAINTAINER_pn-man-db = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-man-pages = "Hongxu Jia <hongxu.jia@windriver.com>"
-RECIPE_MAINTAINER_pn-matchbox-config-gtk = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-desktop = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-keyboard = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-panel-2 = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-session = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-session-sato = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-terminal = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-theme-sato = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-matchbox-wm = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-mc = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-mdadm = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-menu-cache = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-matchbox-config-gtk = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-desktop = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-keyboard = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-panel-2 = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-session = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-session-sato = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-terminal = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-theme-sato = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-matchbox-wm = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-mc = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-mdadm = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-menu-cache = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-mesa = "Otavio Salvador <otavio.salvador@ossystems.com.br>"
 RECIPE_MAINTAINER_pn-mesa-demos = "Otavio Salvador <otavio.salvador@ossystems.com.br>"
 RECIPE_MAINTAINER_pn-mesa-gl = "Otavio Salvador <otavio.salvador@ossystems.com.br>"
@@ -514,7 +514,7 @@
 RECIPE_MAINTAINER_pn-nativesdk-icecc-toolchain = "Joshua Watt <JPEWhacker@gmail.com>"
 RECIPE_MAINTAINER_pn-nativesdk-libtool = "Richard Purdie <richard.purdie@linuxfoundation.org>"
 RECIPE_MAINTAINER_pn-nativesdk-meson = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-nativesdk-packagegroup-sdk-host = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-nativesdk-packagegroup-sdk-host = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-nativesdk-qemu-helper = "Richard Purdie <richard.purdie@linuxfoundation.org>"
 RECIPE_MAINTAINER_pn-nativesdk-sdk-provides-dummy = "Richard Purdie <richard.purdie@linuxfoundation.org>"
 RECIPE_MAINTAINER_pn-newlib = "Alejandro Hernandez <aehs29@gmail.com>"
@@ -528,7 +528,7 @@
 RECIPE_MAINTAINER_pn-ninja = "Khem Raj <raj.khem@gmail.com>"
 RECIPE_MAINTAINER_pn-npth = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-nss-myhostname = "Anuj Mittal <anuj.mittal@intel.com>"
-RECIPE_MAINTAINER_pn-ofono = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-ofono = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-opensbi = "Alistair Francis <alistair.francis@wdc.com>"
 RECIPE_MAINTAINER_pn-openssh = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-openssl = "Alexander Kanavin <alex.kanavin@gmail.com>"
@@ -537,12 +537,12 @@
 RECIPE_MAINTAINER_pn-opkg-keyrings = "Alejandro del Castillo <alejandro.delcastillo@ni.com>"
 RECIPE_MAINTAINER_pn-opkg-utils = "Alejandro del Castillo <alejandro.delcastillo@ni.com>"
 RECIPE_MAINTAINER_pn-orc = "Anuj Mittal <anuj.mittal@intel.com>"
-RECIPE_MAINTAINER_pn-os-release = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-os-release = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-ovmf = "Ricardo Neri <ricardo.neri-calderon@linux.intel.com>"
 RECIPE_MAINTAINER_pn-ovmf-shell-image = "Ricardo Neri <ricardo.neri-calderon@linux.intel.com>"
 RECIPE_MAINTAINER_pn-p11-kit = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-package-index = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-pango = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-package-index = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-pango = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-parted = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-patch = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-patchelf = "Richard Purdie <richard.purdie@linuxfoundation.org>"
@@ -551,13 +551,13 @@
 RECIPE_MAINTAINER_pn-pcmanfm = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-perf = "Bruce Ashfield <bruce.ashfield@gmail.com>"
 RECIPE_MAINTAINER_pn-perl = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-piglit = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-piglit = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-pigz = "Hongxu Jia <hongxu.jia@windriver.com>"
 RECIPE_MAINTAINER_pn-pinentry = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-pixman = "Anuj Mittal <anuj.mittal@intel.com>"
-RECIPE_MAINTAINER_pn-pkgconf = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-pkgconfig = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-pm-utils = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-pkgconf = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-pkgconfig = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-pm-utils = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-pointercal-xinput = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-pong-clock = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-popt = "Yi Zhao <yi.zhao@windriver.com>"
@@ -569,7 +569,7 @@
 RECIPE_MAINTAINER_pn-pseudo = "Mark Hatle <mark.hatle@windriver.com>"
 RECIPE_MAINTAINER_pn-psmisc = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-psplash = "Yi Zhao <yi.zhao@windriver.com>"
-RECIPE_MAINTAINER_pn-ptest-runner = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-ptest-runner = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-pulseaudio = "Tanu Kaskinen <tanuk@iki.fi>"
 RECIPE_MAINTAINER_pn-pulseaudio-client-conf-sato = "Tanu Kaskinen <tanuk@iki.fi>"
 RECIPE_MAINTAINER_pn-puzzles = "Anuj Mittal <anuj.mittal@intel.com>"
@@ -622,10 +622,10 @@
 RECIPE_MAINTAINER_pn-rpm = "Mark Hatle <mark.hatle@windriver.com>"
 RECIPE_MAINTAINER_pn-rsync = "Yi Zhao <yi.zhao@windriver.com>"
 RECIPE_MAINTAINER_pn-rt-tests = "Alexander Kanavin <alex.kanavin@gmail.com>"
-RECIPE_MAINTAINER_pn-ruby = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-run-postinsts = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-ruby = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-run-postinsts = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-rxvt-unicode = "Armin Kuster <akuster808@gmail.com>"
-RECIPE_MAINTAINER_pn-sato-screenshot = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-sato-screenshot = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-sbc = "Tanu Kaskinen <tanuk@iki.fi>"
 RECIPE_MAINTAINER_pn-screen = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-sed = "Chen Qi <Qi.Chen@windriver.com>"
@@ -665,8 +665,8 @@
 RECIPE_MAINTAINER_pn-systemtap = "Victor Kamensky <kamensky@cisco.com>"
 RECIPE_MAINTAINER_pn-systemtap-native = "Victor Kamensky <kamensky@cisco.com>"
 RECIPE_MAINTAINER_pn-systemtap-uprobes = "Victor Kamensky <kamensky@cisco.com>"
-RECIPE_MAINTAINER_pn-sysvinit = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-sysvinit-inittab = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-sysvinit = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-sysvinit-inittab = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-taglib = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-tar = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-tcf-agent = "Anuj Mittal <anuj.mittal@intel.com>"
@@ -682,12 +682,12 @@
 RECIPE_MAINTAINER_pn-tzdata = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-u-boot = "Marek Vasut <marek.vasut@gmail.com>"
 RECIPE_MAINTAINER_pn-u-boot-tools = "Marek Vasut <marek.vasut@gmail.com>"
-RECIPE_MAINTAINER_pn-udev-extraconf = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-unfs3 = "Ross Burton <ross.burton@intel.com>"
-RECIPE_MAINTAINER_pn-unifdef = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-udev-extraconf = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-unfs3 = "Ross Burton <ross.burton@arm.com>"
+RECIPE_MAINTAINER_pn-unifdef = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-uninative-tarball = "Richard Purdie <richard.purdie@linuxfoundation.org>"
 RECIPE_MAINTAINER_pn-unzip = "Denys Dmytriyenko <denys@ti.com>"
-RECIPE_MAINTAINER_pn-update-rc.d = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-update-rc.d = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-usbinit = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-usbutils = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-util-linux = "Chen Qi <Qi.Chen@windriver.com>"
@@ -700,11 +700,11 @@
 RECIPE_MAINTAINER_pn-virglrenderer = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-volatile-binds = "Chen Qi <Qi.Chen@windriver.com>"
 RECIPE_MAINTAINER_pn-vte = "Anuj Mittal <anuj.mittal@intel.com>"
-RECIPE_MAINTAINER_pn-vulkan-demos = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-vulkan-demos = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-vulkan-headers = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-vulkan-loader = "Anuj Mittal <anuj.mittal@intel.com>"
 RECIPE_MAINTAINER_pn-vulkan-tools = "Anuj Mittal <anuj.mittal@intel.com>"
-RECIPE_MAINTAINER_pn-waffle = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-waffle = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-watchdog = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-watchdog-config = "Alexander Kanavin <alex.kanavin@gmail.com>"
 RECIPE_MAINTAINER_pn-wayland = "Denys Dmytriyenko <denys@ti.com>"
@@ -744,7 +744,7 @@
 RECIPE_MAINTAINER_pn-xf86-video-vesa = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-xf86-video-vmware = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-xhost = "Armin Kuster <akuster808@gmail.com>"
-RECIPE_MAINTAINER_pn-xinetd = "Ross Burton <ross.burton@intel.com>"
+RECIPE_MAINTAINER_pn-xinetd = "Ross Burton <ross.burton@arm.com>"
 RECIPE_MAINTAINER_pn-xinit = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-xinput = "Armin Kuster <akuster808@gmail.com>"
 RECIPE_MAINTAINER_pn-xinput-calibrator = "Armin Kuster <akuster808@gmail.com>"
diff --git a/poky/meta/conf/distro/include/security_flags.inc b/poky/meta/conf/distro/include/security_flags.inc
index 568d036..a9e5b31 100644
--- a/poky/meta/conf/distro/include/security_flags.inc
+++ b/poky/meta/conf/distro/include/security_flags.inc
@@ -26,8 +26,8 @@
 SECURITY_CFLAGS ?= "${SECURITY_STACK_PROTECTOR} ${SECURITY_PIE_CFLAGS} ${lcl_maybe_fortify} ${SECURITY_STRINGFORMAT}"
 SECURITY_NO_PIE_CFLAGS ?= "${SECURITY_STACK_PROTECTOR} ${lcl_maybe_fortify} ${SECURITY_STRINGFORMAT}"
 
-SECURITY_LDFLAGS ?= "${SECURITY_STACK_PROTECTOR} -Wl,-z,relro,-z,now"
-SECURITY_X_LDFLAGS ?= "${SECURITY_STACK_PROTECTOR} -Wl,-z,relro"
+SECURITY_LDFLAGS ?= "-Wl,-z,relro,-z,now"
+SECURITY_X_LDFLAGS ?= "-Wl,-z,relro"
 
 # powerpc does not get on with pie for reasons not looked into as yet
 GCCPIE_powerpc = ""
diff --git a/poky/meta/conf/layer.conf b/poky/meta/conf/layer.conf
index da93d64..098ef12 100644
--- a/poky/meta/conf/layer.conf
+++ b/poky/meta/conf/layer.conf
@@ -11,7 +11,7 @@
 
 # This should only be incremented on significant changes that will
 # cause compatibility issues with other layers
-LAYERVERSION_core = "11"
+LAYERVERSION_core = "12"
 LAYERSERIES_COMPAT_core = "gatesgarth"
 
 BBLAYERS_LAYERINDEX_NAME_core = "openembedded-core"
diff --git a/poky/meta/conf/machine/include/arm/arch-arm64.inc b/poky/meta/conf/machine/include/arm/arch-arm64.inc
index 53f4566..6d5b22f 100644
--- a/poky/meta/conf/machine/include/arm/arch-arm64.inc
+++ b/poky/meta/conf/machine/include/arm/arch-arm64.inc
@@ -12,6 +12,8 @@
 ARMPKGARCH_tune-aarch64_be ?= "aarch64_be"
 TUNE_FEATURES_tune-aarch64 = "aarch64"
 TUNE_FEATURES_tune-aarch64_be = "${TUNE_FEATURES_tune-aarch64} bigendian"
+TUNE_PKGARCH_64_tune-aarch64 = "aarch64"
+TUNE_PKGARCH_64_tune-aarch64_be = "aarch64_be"
 BASE_LIB_tune-aarch64 = "lib64"
 BASE_LIB_tune-aarch64_be = "lib64"
 
@@ -20,7 +22,7 @@
 
 ARMPKGSFX_ENDIAN_64 = "${@bb.utils.contains('TUNE_FEATURES', 'bigendian', '_be', '', d)}"
 TUNE_ARCH_64 = "aarch64${ARMPKGSFX_ENDIAN_64}"
-TUNE_PKGARCH_64 = "aarch64${ARMPKGSFX_ENDIAN_64}"
+TUNE_PKGARCH_64 = "${ARMPKGARCH}${ARMPKGSFX_ENDIAN_64}"
 ABIEXTENSION_64 = ""
 TARGET_FPU_64 = ""
 
diff --git a/poky/meta/conf/machine/include/tune-cortexa53.inc b/poky/meta/conf/machine/include/tune-cortexa53.inc
index b7327d0..c0bb28a 100644
--- a/poky/meta/conf/machine/include/tune-cortexa53.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa53.inc
@@ -8,14 +8,11 @@
 # Little Endian base configs
 AVAILTUNES += "cortexa53 cortexa53-crypto"
 ARMPKGARCH_tune-cortexa53             = "cortexa53"
-ARMPKGARCH_tune-cortexa53-crypto      = "cortexa53"
+ARMPKGARCH_tune-cortexa53-crypto      = "cortexa53-crypto"
 TUNE_FEATURES_tune-cortexa53          = "aarch64 cortexa53 crc"
 TUNE_FEATURES_tune-cortexa53-crypto   = "aarch64 cortexa53 crc crypto"
 PACKAGE_EXTRA_ARCHS_tune-cortexa53             = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc} cortexa53"
 PACKAGE_EXTRA_ARCHS_tune-cortexa53-crypto      = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc-crypto} cortexa53 cortexa53-crypto"
 
-TUNE_PKGARCH_tune-cortexa53 = "cortexa53"
-TUNE_PKGARCH_tune-cortexa53-crypto = "cortexa53-crypto"
-
 BASE_LIB_tune-cortexa53               = "lib64"
 BASE_LIB_tune-cortexa53-crypto        = "lib64"
diff --git a/poky/meta/conf/machine/include/tune-cortexa55.inc b/poky/meta/conf/machine/include/tune-cortexa55.inc
index 2749448..89032b5 100644
--- a/poky/meta/conf/machine/include/tune-cortexa55.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa55.inc
@@ -9,6 +9,5 @@
 AVAILTUNES += "cortexa55"
 ARMPKGARCH_tune-cortexa55             = "cortexa55"
 TUNE_FEATURES_tune-cortexa55          = "aarch64 cortexa55 crc crypto"
-TUNE_PKGARCH_tune-cortexa55           = "cortexa55"
 PACKAGE_EXTRA_ARCHS_tune-cortexa55    = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc-crypto} cortexa55"
 BASE_LIB_tune-cortexa55               = "lib64"
diff --git a/poky/meta/conf/machine/include/tune-cortexa57-cortexa53.inc b/poky/meta/conf/machine/include/tune-cortexa57-cortexa53.inc
index b95d63e..ba4b073 100644
--- a/poky/meta/conf/machine/include/tune-cortexa57-cortexa53.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa57-cortexa53.inc
@@ -11,6 +11,5 @@
 AVAILTUNES += "cortexa57-cortexa53"
 ARMPKGARCH_tune-cortexa57-cortexa53 = "cortexa57-cortexa53"
 TUNE_FEATURES_tune-cortexa57-cortexa53 = "aarch64 cortexa57-cortexa53"
-TUNE_PKGARCH_tune-cortexa57-cortexa53 = "cortexa57-cortexa53"
 PACKAGE_EXTRA_ARCHS_tune-cortexa57-cortexa53 = "${PACKAGE_EXTRA_ARCHS_tune-aarch64} cortexa57-cortexa53"
 BASE_LIB_tune-cortexa57-cortexa53 = "lib64"
diff --git a/poky/meta/conf/machine/include/tune-cortexa57.inc b/poky/meta/conf/machine/include/tune-cortexa57.inc
index e8ddeb5..0811d50 100644
--- a/poky/meta/conf/machine/include/tune-cortexa57.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa57.inc
@@ -8,12 +8,10 @@
 # Little Endian base configs
 AVAILTUNES += "cortexa57 cortexa57-crypto"
 ARMPKGARCH_tune-cortexa57             = "cortexa57"
-ARMPKGARCH_tune-cortexa57-crypto      = "cortexa57"
+ARMPKGARCH_tune-cortexa57-crypto      = "cortexa57-crypto"
 TUNE_FEATURES_tune-cortexa57          = "aarch64 cortexa57 crc"
 TUNE_FEATURES_tune-cortexa57-crypto   = "aarch64 cortexa57 crc crypto"
 PACKAGE_EXTRA_ARCHS_tune-cortexa57             = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc} cortexa57"
 PACKAGE_EXTRA_ARCHS_tune-cortexa57-crypto      = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc-crypto} cortexa57 cortexa57-crypto"
-TUNE_PKGARCH_tune-cortexa57 = "cortexa57"
-TUNE_PKGARCH_tune-cortexa57-crypto = "cortexa57-crypto"
 BASE_LIB_tune-cortexa57               = "lib64"
 BASE_LIB_tune-cortexa57-crypto        = "lib64"
diff --git a/poky/meta/conf/machine/include/tune-cortexa72-cortexa53.inc b/poky/meta/conf/machine/include/tune-cortexa72-cortexa53.inc
index fd1ffeb..e857f87 100644
--- a/poky/meta/conf/machine/include/tune-cortexa72-cortexa53.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa72-cortexa53.inc
@@ -10,13 +10,11 @@
 # cortexa72.cortexa53 implies crc support
 AVAILTUNES += "cortexa72-cortexa53 cortexa72-cortexa53-crypto"
 ARMPKGARCH_tune-cortexa72-cortexa53                  = "cortexa72-cortexa53"
-ARMPKGARCH_tune-cortexa72-cortexa53-crypto           = "cortexa72-cortexa53"
+ARMPKGARCH_tune-cortexa72-cortexa53-crypto           = "cortexa72-cortexa53-crypto"
 TUNE_FEATURES_tune-cortexa72-cortexa53               = "aarch64 crc cortexa72-cortexa53"
 TUNE_FEATURES_tune-cortexa72-cortexa53-crypto        = "aarch64 crc crypto cortexa72-cortexa53"
 PACKAGE_EXTRA_ARCHS_tune-cortexa72-cortexa53         = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc}        cortexa72-cortexa53"
 PACKAGE_EXTRA_ARCHS_tune-cortexa72-cortexa53-crypto  = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc-crypto} cortexa72-cortexa53 cortexa72-cortexa53-crypto"
-TUNE_PKGARCH_tune-cortexa72-cortexa53                = "cortexa72-cortexa53"
-TUNE_PKGARCH_tune-cortexa72-cortexa53-crypto         = "cortexa72-cortexa53-crypto"
 BASE_LIB_tune-cortexa72-cortexa53                    = "lib64"
 BASE_LIB_tune-cortexa72-cortexa53-crypto             = "lib64"
 
diff --git a/poky/meta/conf/machine/include/tune-cortexa72.inc b/poky/meta/conf/machine/include/tune-cortexa72.inc
index 23640d5..00f7745 100644
--- a/poky/meta/conf/machine/include/tune-cortexa72.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa72.inc
@@ -10,5 +10,4 @@
 ARMPKGARCH_tune-cortexa72             = "cortexa72"
 TUNE_FEATURES_tune-cortexa72          = "aarch64 cortexa72 crc crypto"
 PACKAGE_EXTRA_ARCHS_tune-cortexa72    = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc-crypto} cortexa72"
-TUNE_PKGARCH_tune-cortexa72           = "cortexa72"
 BASE_LIB_tune-cortexa72               = "lib64"
diff --git a/poky/meta/conf/machine/include/tune-cortexa73-cortexa53.inc b/poky/meta/conf/machine/include/tune-cortexa73-cortexa53.inc
index ab87c88..ba2b9b1 100644
--- a/poky/meta/conf/machine/include/tune-cortexa73-cortexa53.inc
+++ b/poky/meta/conf/machine/include/tune-cortexa73-cortexa53.inc
@@ -10,13 +10,11 @@
 # cortexa73.cortexa53 implies crc support
 AVAILTUNES += "cortexa73-cortexa53 cortexa73-cortexa53-crypto"
 ARMPKGARCH_tune-cortexa73-cortexa53                  = "cortexa73-cortexa53"
-ARMPKGARCH_tune-cortexa73-cortexa53-crypto           = "cortexa73-cortexa53"
+ARMPKGARCH_tune-cortexa73-cortexa53-crypto           = "cortexa73-cortexa53-crypto"
 TUNE_FEATURES_tune-cortexa73-cortexa53               = "aarch64 crc cortexa73-cortexa53"
 TUNE_FEATURES_tune-cortexa73-cortexa53-crypto        = "aarch64 crc crypto cortexa73-cortexa53"
 PACKAGE_EXTRA_ARCHS_tune-cortexa73-cortexa53         = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc}        cortexa73-cortexa53"
 PACKAGE_EXTRA_ARCHS_tune-cortexa73-cortexa53-crypto  = "${PACKAGE_EXTRA_ARCHS_tune-armv8a-crc-crypto} cortexa73-cortexa53 cortexa73-cortexa53-crypto"
-TUNE_PKGARCH_tune-cortexa73-cortexa53                = "cortexa73-cortexa53"
-TUNE_PKGARCH_tune-cortexa73-cortexa53-crypto         = "cortexa73-cortexa53-crypto"
 BASE_LIB_tune-cortexa73-cortexa53                    = "lib64"
 BASE_LIB_tune-cortexa73-cortexa53-crypto             = "lib64"
 
diff --git a/poky/meta/conf/machine/qemuarm.conf b/poky/meta/conf/machine/qemuarm.conf
index 367fcef..4e605d3 100644
--- a/poky/meta/conf/machine/qemuarm.conf
+++ b/poky/meta/conf/machine/qemuarm.conf
@@ -8,6 +8,7 @@
 KERNEL_IMAGETYPE = "zImage"
 
 SERIAL_CONSOLES ?= "115200;ttyAMA0 115200;hvc0"
+SERIAL_CONSOLES_CHECK = "${SERIAL_CONSOLES}"
 
 # For runqemu
 QB_SYSTEM_NAME = "qemu-system-arm"
diff --git a/poky/meta/conf/machine/qemuarm64.conf b/poky/meta/conf/machine/qemuarm64.conf
index 7965fac..e8aac38 100644
--- a/poky/meta/conf/machine/qemuarm64.conf
+++ b/poky/meta/conf/machine/qemuarm64.conf
@@ -8,6 +8,7 @@
 KERNEL_IMAGETYPE = "Image"
 
 SERIAL_CONSOLES ?= "115200;ttyAMA0 115200;hvc0"
+SERIAL_CONSOLES_CHECK = "${SERIAL_CONSOLES}"
 
 # For runqemu
 QB_SYSTEM_NAME = "qemu-system-aarch64"
diff --git a/poky/meta/lib/oe/classextend.py b/poky/meta/lib/oe/classextend.py
index e1049ce..d3d8fbe 100644
--- a/poky/meta/lib/oe/classextend.py
+++ b/poky/meta/lib/oe/classextend.py
@@ -100,7 +100,6 @@
             newdeps[self.map_depends(dep)] = deps[dep]
 
         if not varname.endswith("_NONML"):
-            #if varname == "DEPENDS":
             self.d.renameVar(varname, varname + "_NONML")
             self.d.setVar(varname, "${@oe.classextend.get_depends('%s', d)}" % varname)
             self.d.appendVarFlag(varname, "vardeps", " " + varname + "_NONML")
diff --git a/poky/meta/lib/oe/package_manager.py b/poky/meta/lib/oe/package_manager.py
index c055d2b..35e5cff 100644
--- a/poky/meta/lib/oe/package_manager.py
+++ b/poky/meta/lib/oe/package_manager.py
@@ -1800,7 +1800,7 @@
     def fix_broken_dependencies(self):
         os.environ['APT_CONFIG'] = self.apt_conf_file
 
-        cmd = "%s %s -f install" % (self.apt_get_cmd, self.apt_args)
+        cmd = "%s %s --allow-unauthenticated -f install" % (self.apt_get_cmd, self.apt_args)
 
         try:
             subprocess.check_output(cmd.split(), stderr=subprocess.STDOUT)
diff --git a/poky/meta/lib/oe/patch.py b/poky/meta/lib/oe/patch.py
index 2b1eee1..7ca2e28 100644
--- a/poky/meta/lib/oe/patch.py
+++ b/poky/meta/lib/oe/patch.py
@@ -416,7 +416,7 @@
                     date = newdate
                 if not subject:
                     subject = newsubject
-        if subject and outlines and not outlines[0].strip() == subject:
+        if subject and not (outlines and outlines[0].strip() == subject):
             outlines.insert(0, '%s\n\n' % subject.strip())
 
         # Write out commit message to a file
@@ -439,7 +439,6 @@
     def extractPatches(tree, startcommit, outdir, paths=None):
         import tempfile
         import shutil
-        import re
         tempdir = tempfile.mkdtemp(prefix='oepatch')
         try:
             shellcmd = ["git", "format-patch", "--no-signature", "--no-numbered", startcommit, "-o", tempdir]
@@ -455,13 +454,10 @@
                         try:
                             with open(srcfile, 'r', encoding=encoding) as f:
                                 for line in f:
-                                    checkline = line
-                                    if checkline.startswith('Subject: '):
-                                        checkline = re.sub(r'\[.+?\]\s*', '', checkline[9:])
-                                    if checkline.startswith(GitApplyTree.patch_line_prefix):
+                                    if line.startswith(GitApplyTree.patch_line_prefix):
                                         outfile = line.split()[-1].strip()
                                         continue
-                                    if checkline.startswith(GitApplyTree.ignore_commit_prefix):
+                                    if line.startswith(GitApplyTree.ignore_commit_prefix):
                                         continue
                                     patchlines.append(line)
                         except UnicodeDecodeError:
@@ -508,8 +504,7 @@
         with open(commithook, 'w') as f:
             # NOTE: the formatting here is significant; if you change it you'll also need to
             # change other places which read it back
-            f.write('echo >> $1\n')
-            f.write('echo "%s: $PATCHFILE" >> $1\n' % GitApplyTree.patch_line_prefix)
+            f.write('echo "\n%s: $PATCHFILE" >> $1' % GitApplyTree.patch_line_prefix)
         os.chmod(commithook, 0o755)
         shutil.copy2(commithook, applyhook)
         try:
diff --git a/poky/meta/lib/oeqa/core/context.py b/poky/meta/lib/oeqa/core/context.py
index 4705d60..7d3fa3b 100644
--- a/poky/meta/lib/oeqa/core/context.py
+++ b/poky/meta/lib/oeqa/core/context.py
@@ -156,6 +156,8 @@
         fh = logging.FileHandler(args.output_log)
         fh.setFormatter(formatter)
         logger.addHandler(fh)
+        if getattr(args, 'verbose', False):
+            logger.setLevel('DEBUG')
 
         return logger
 
diff --git a/poky/meta/lib/oeqa/runtime/cases/apt.py b/poky/meta/lib/oeqa/runtime/cases/apt.py
index c5378d9..53745df 100644
--- a/poky/meta/lib/oeqa/runtime/cases/apt.py
+++ b/poky/meta/lib/oeqa/runtime/cases/apt.py
@@ -34,7 +34,7 @@
     def setup_source_config_for_package_install(self):
         apt_get_source_server = 'http://%s:%s/' % (self.tc.target.server_ip, self.repo_server.port)
         apt_get_sourceslist_dir = '/etc/apt/'
-        self.target.run('cd %s; echo deb %s ./ > sources.list' % (apt_get_sourceslist_dir, apt_get_source_server))
+        self.target.run('cd %s; echo deb [ allow-insecure=yes ] %s ./ > sources.list' % (apt_get_sourceslist_dir, apt_get_source_server))
 
     def cleanup_source_config_for_package_install(self):
         apt_get_sourceslist_dir = '/etc/apt/'
diff --git a/poky/meta/lib/oeqa/selftest/cases/archiver.py b/poky/meta/lib/oeqa/selftest/cases/archiver.py
index 606eaab..bc5447d 100644
--- a/poky/meta/lib/oeqa/selftest/cases/archiver.py
+++ b/poky/meta/lib/oeqa/selftest/cases/archiver.py
@@ -126,6 +126,7 @@
 
         features = 'INHERIT += "archiver"\n'
         features += 'ARCHIVER_MODE[srpm] = "1"\n'
+        features += 'PACKAGE_CLASSES = "package_rpm"\n'
         self.write_config(features)
 
         bitbake('-n core-image-sato')
diff --git a/poky/meta/lib/oeqa/selftest/cases/devtool.py b/poky/meta/lib/oeqa/selftest/cases/devtool.py
index 5886862..7d8f895 100644
--- a/poky/meta/lib/oeqa/selftest/cases/devtool.py
+++ b/poky/meta/lib/oeqa/selftest/cases/devtool.py
@@ -676,7 +676,7 @@
 
         bbclassextended = False
         inheritnative = False
-        testrecipes = 'mtools-native apt-native desktop-file-utils-native'.split()
+        testrecipes = 'cdrtools-native mtools-native apt-native desktop-file-utils-native'.split()
         for testrecipe in testrecipes:
             checkextend = 'native' in (get_bb_var('BBCLASSEXTEND', testrecipe) or '').split()
             if not bbclassextended:
@@ -1108,6 +1108,59 @@
                            ('??', '.*/0001-Add-new-file.patch$')]
         self._check_repo_status(os.path.dirname(recipefile), expected_status)
 
+    def test_devtool_update_recipe_with_gitignore(self):
+        # First, modify the recipe
+        testrecipe = 'devtool-test-ignored'
+        bb_vars = get_bb_vars(['FILE'], testrecipe)
+        recipefile = bb_vars['FILE']
+        patchfile = os.path.join(os.path.dirname(recipefile), testrecipe, testrecipe + '.patch')
+        newpatchfile = os.path.join(os.path.dirname(recipefile), testrecipe, testrecipe + '.patch.expected')
+        tempdir = tempfile.mkdtemp(prefix='devtoolqa')
+        self.track_for_cleanup(tempdir)
+        self.track_for_cleanup(self.workspacedir)
+        self.add_command_to_tearDown('bitbake-layers remove-layer */workspace')
+        # (don't bother with cleaning the recipe on teardown, we won't be building it)
+        result = runCmd('devtool modify %s' % testrecipe)
+        self.add_command_to_tearDown('cd %s; rm %s/*; git checkout %s %s' % (os.path.dirname(recipefile), testrecipe, testrecipe, os.path.basename(recipefile)))
+        result = runCmd('devtool finish --force-patch-refresh %s meta-selftest' % testrecipe)
+        # Check recipe got changed as expected
+        with open(newpatchfile, 'r') as f:
+            desiredlines = f.readlines()
+        with open(patchfile, 'r') as f:
+            newlines = f.readlines()
+        # Ignore the initial lines, because oe-selftest creates own meta-selftest repo
+        # which changes the metadata subject which is added into the patch, but keep
+        # .patch.expected as it is in case someone runs devtool finish --force-patch-refresh
+        # devtool-test-ignored manually, then it should generate exactly the same .patch file
+        self.assertEqual(desiredlines[5:], newlines[5:])
+
+    def test_devtool_update_recipe_long_filename(self):
+        # First, modify the recipe
+        testrecipe = 'devtool-test-long-filename'
+        bb_vars = get_bb_vars(['FILE'], testrecipe)
+        recipefile = bb_vars['FILE']
+        patchfilename = '0001-I-ll-patch-you-only-if-devtool-lets-me-to-do-it-corr.patch'
+        patchfile = os.path.join(os.path.dirname(recipefile), testrecipe, patchfilename)
+        newpatchfile = os.path.join(os.path.dirname(recipefile), testrecipe, patchfilename + '.expected')
+        tempdir = tempfile.mkdtemp(prefix='devtoolqa')
+        self.track_for_cleanup(tempdir)
+        self.track_for_cleanup(self.workspacedir)
+        self.add_command_to_tearDown('bitbake-layers remove-layer */workspace')
+        # (don't bother with cleaning the recipe on teardown, we won't be building it)
+        result = runCmd('devtool modify %s' % testrecipe)
+        self.add_command_to_tearDown('cd %s; rm %s/*; git checkout %s %s' % (os.path.dirname(recipefile), testrecipe, testrecipe, os.path.basename(recipefile)))
+        result = runCmd('devtool finish --force-patch-refresh %s meta-selftest' % testrecipe)
+        # Check recipe got changed as expected
+        with open(newpatchfile, 'r') as f:
+            desiredlines = f.readlines()
+        with open(patchfile, 'r') as f:
+            newlines = f.readlines()
+        # Ignore the initial lines, because oe-selftest creates own meta-selftest repo
+        # which changes the metadata subject which is added into the patch, but keep
+        # .patch.expected as it is in case someone runs devtool finish --force-patch-refresh
+        # devtool-test-ignored manually, then it should generate exactly the same .patch file
+        self.assertEqual(desiredlines[5:], newlines[5:])
+
     def test_devtool_update_recipe_local_files_3(self):
         # First, modify the recipe
         testrecipe = 'devtool-test-localonly'
diff --git a/poky/meta/lib/oeqa/selftest/cases/wic.py b/poky/meta/lib/oeqa/selftest/cases/wic.py
index c8765e5..9e7be61 100644
--- a/poky/meta/lib/oeqa/selftest/cases/wic.py
+++ b/poky/meta/lib/oeqa/selftest/cases/wic.py
@@ -790,41 +790,50 @@
             tempf.write("part " \
                      "--source rootfs --ondisk hda --align 4 --fixed-size %d "
                      "--fstype=ext4\n" % size)
+
+        return wkspath
+
+    def _get_wic_partitions(self, wkspath, native_sysroot=None, ignore_status=False):
+        p = runCmd("wic create %s -e core-image-minimal -o %s" % (wkspath, self.resultdir),
+                   ignore_status=ignore_status)
+
+        if p.status:
+            return (p, None)
+
         wksname = os.path.splitext(os.path.basename(wkspath))[0]
 
-        return wkspath, wksname
-
-    def test_fixed_size(self):
-        """
-        Test creation of a simple image with partition size controlled through
-        --fixed-size flag
-        """
-        wkspath, wksname = Wic2._make_fixed_size_wks(200)
-
-        runCmd("wic create %s -e core-image-minimal -o %s" \
-                                   % (wkspath, self.resultdir))
-        os.remove(wkspath)
         wicout = glob(self.resultdir + "%s-*direct" % wksname)
-        self.assertEqual(1, len(wicout))
+
+        if not wicout:
+            return (p, None)
 
         wicimg = wicout[0]
 
-        native_sysroot = get_bb_var("RECIPE_SYSROOT_NATIVE", "wic-tools")
+        if not native_sysroot:
+            native_sysroot = get_bb_var("RECIPE_SYSROOT_NATIVE", "wic-tools")
 
         # verify partition size with wic
-        res = runCmd("parted -m %s unit mib p 2>/dev/null" % wicimg,
+        res = runCmd("parted -m %s unit kib p 2>/dev/null" % wicimg,
                      native_sysroot=native_sysroot)
 
         # parse parted output which looks like this:
         # BYT;\n
         # /var/tmp/wic/build/tmpfwvjjkf_-201611101222-hda.direct:200MiB:file:512:512:msdos::;\n
         # 1:0.00MiB:200MiB:200MiB:ext4::;\n
-        partlns = res.output.splitlines()[2:]
+        return (p, res.output.splitlines()[2:])
 
-        self.assertEqual(1, len(partlns),
-                         msg="Partition list '%s'" % res.output)
-        self.assertEqual("1:0.00MiB:200MiB:200MiB:ext4::;", partlns[0],
-                         msg="Partition list '%s'" % res.output)
+    def test_fixed_size(self):
+        """
+        Test creation of a simple image with partition size controlled through
+        --fixed-size flag
+        """
+        wkspath = Wic2._make_fixed_size_wks(200)
+        _, partlns = self._get_wic_partitions(wkspath)
+        os.remove(wkspath)
+
+        self.assertEqual(partlns, [
+                        "1:4.00kiB:204804kiB:204800kiB:ext4::;",
+                        ])
 
     def test_fixed_size_error(self):
         """
@@ -832,13 +841,72 @@
         --fixed-size flag. The size of partition is intentionally set to 1MiB
         in order to trigger an error in wic.
         """
-        wkspath, wksname = Wic2._make_fixed_size_wks(1)
-
-        self.assertEqual(1, runCmd("wic create %s -e core-image-minimal -o %s" \
-                                   % (wkspath, self.resultdir), ignore_status=True).status)
+        wkspath = Wic2._make_fixed_size_wks(1)
+        p, _ = self._get_wic_partitions(wkspath, ignore_status=True)
         os.remove(wkspath)
-        wicout = glob(self.resultdir + "%s-*direct" % wksname)
-        self.assertEqual(0, len(wicout))
+
+        self.assertNotEqual(p.status, 0, "wic exited successfully when an error was expected:\n%s" % p.output)
+
+    def test_offset(self):
+        native_sysroot = get_bb_var("RECIPE_SYSROOT_NATIVE", "wic-tools")
+
+        with NamedTemporaryFile("w", suffix=".wks") as tempf:
+            # Test that partitions are placed at the correct offsets, default KB
+            tempf.write("bootloader --ptable gpt\n" \
+                        "part /    --source rootfs --ondisk hda --offset 32     --fixed-size 100M --fstype=ext4\n" \
+                        "part /bar                 --ondisk hda --offset 102432 --fixed-size 100M --fstype=ext4\n")
+            tempf.flush()
+
+            _, partlns = self._get_wic_partitions(tempf.name, native_sysroot)
+            self.assertEqual(partlns, [
+                "1:32.0kiB:102432kiB:102400kiB:ext4:primary:;",
+                "2:102432kiB:204832kiB:102400kiB:ext4:primary:;",
+                ])
+
+        with NamedTemporaryFile("w", suffix=".wks") as tempf:
+            # Test that partitions are placed at the correct offsets, same with explicit KB
+            tempf.write("bootloader --ptable gpt\n" \
+                        "part /    --source rootfs --ondisk hda --offset 32K     --fixed-size 100M --fstype=ext4\n" \
+                        "part /bar                 --ondisk hda --offset 102432K --fixed-size 100M --fstype=ext4\n")
+            tempf.flush()
+
+            _, partlns = self._get_wic_partitions(tempf.name, native_sysroot)
+            self.assertEqual(partlns, [
+                "1:32.0kiB:102432kiB:102400kiB:ext4:primary:;",
+                "2:102432kiB:204832kiB:102400kiB:ext4:primary:;",
+                ])
+
+        with NamedTemporaryFile("w", suffix=".wks") as tempf:
+            # Test that partitions are placed at the correct offsets using MB
+            tempf.write("bootloader --ptable gpt\n" \
+                        "part /    --source rootfs --ondisk hda --offset 32K  --fixed-size 100M --fstype=ext4\n" \
+                        "part /bar                 --ondisk hda --offset 101M --fixed-size 100M --fstype=ext4\n")
+            tempf.flush()
+
+            _, partlns = self._get_wic_partitions(tempf.name, native_sysroot)
+            self.assertEqual(partlns, [
+                "1:32.0kiB:102432kiB:102400kiB:ext4:primary:;",
+                "2:103424kiB:205824kiB:102400kiB:ext4:primary:;",
+                ])
+
+        with NamedTemporaryFile("w", suffix=".wks") as tempf:
+            # Test that image creation fails if the partitions would overlap
+            tempf.write("bootloader --ptable gpt\n" \
+                        "part /    --source rootfs --ondisk hda --offset 32     --fixed-size 100M --fstype=ext4\n" \
+                        "part /bar                 --ondisk hda --offset 102431 --fixed-size 100M --fstype=ext4\n")
+            tempf.flush()
+
+            p, _ = self._get_wic_partitions(tempf.name, ignore_status=True)
+            self.assertNotEqual(p.status, 0, "wic exited successfully when an error was expected:\n%s" % p.output)
+
+        with NamedTemporaryFile("w", suffix=".wks") as tempf:
+            # Test that partitions are not allowed to overlap with the booloader
+            tempf.write("bootloader --ptable gpt\n" \
+                        "part /    --source rootfs --ondisk hda --offset 8 --fixed-size 100M --fstype=ext4\n")
+            tempf.flush()
+
+            p, _ = self._get_wic_partitions(tempf.name, ignore_status=True)
+            self.assertNotEqual(p.status, 0, "wic exited successfully when an error was expected:\n%s" % p.output)
 
     @only_for_arch(['i586', 'i686', 'x86_64'])
     def test_rawcopy_plugin_qemu(self):
diff --git a/poky/meta/lib/oeqa/selftest/context.py b/poky/meta/lib/oeqa/selftest/context.py
index 48ec5d4..494e9db 100644
--- a/poky/meta/lib/oeqa/selftest/context.py
+++ b/poky/meta/lib/oeqa/selftest/context.py
@@ -10,6 +10,7 @@
 import sys
 import importlib
 import subprocess
+import unittest
 from random import choice
 
 import oeqa
@@ -22,18 +23,22 @@
 from oeqa.utils.commands import runCmd, get_bb_vars, get_test_layer
 
 class OESelftestTestContext(OETestContext):
-    def __init__(self, td=None, logger=None, machines=None, config_paths=None):
+    def __init__(self, td=None, logger=None, machines=None, config_paths=None, newbuilddir=None):
         super(OESelftestTestContext, self).__init__(td, logger)
 
         self.machines = machines
         self.custommachine = None
         self.config_paths = config_paths
+        self.newbuilddir = newbuilddir
 
     def setup_builddir(self, suffix, selftestdir, suite):
         builddir = os.environ['BUILDDIR']
         if not selftestdir:
             selftestdir = get_test_layer()
-        newbuilddir = builddir + suffix
+        if self.newbuilddir:
+            newbuilddir = os.path.join(self.newbuilddir, 'build' + suffix)
+        else:
+            newbuilddir = builddir + suffix
         newselftestdir = newbuilddir + "/meta-selftest"
 
         if os.path.exists(newbuilddir):
@@ -56,9 +61,9 @@
 
         os.chdir(newbuilddir)
 
-        for t in suite:
+        def patch_test(t):
             if not hasattr(t, "tc"):
-                continue
+                return
             cp = t.tc.config_paths
             for p in cp:
                 if selftestdir in cp[p] and newselftestdir not in cp[p]:
@@ -66,6 +71,15 @@
                 if builddir in cp[p] and newbuilddir not in cp[p]:
                     cp[p] = cp[p].replace(builddir, newbuilddir)
 
+        def patch_suite(s):
+            for x in s:
+                if isinstance(x, unittest.TestSuite):
+                    patch_suite(x)
+                else:
+                    patch_test(x)
+
+        patch_suite(suite)
+
         return (builddir, newbuilddir)
 
     def prepareSuite(self, suites, processes):
@@ -133,6 +147,8 @@
                 action='append', default=None,
                 help='Exclude all (unhidden) tests that match any of the specified tag(s). (exclude applies before select)')
 
+        parser.add_argument('-B', '--newbuilddir', help='New build directory to use for tests.')
+        parser.add_argument('-v', '--verbose', action='store_true')
         parser.set_defaults(func=self.run)
 
     def _get_available_machines(self):
@@ -187,6 +203,7 @@
         self.tc_kwargs['init']['config_paths']['builddir'] = builddir
         self.tc_kwargs['init']['config_paths']['localconf'] = os.path.join(builddir, "conf/local.conf")
         self.tc_kwargs['init']['config_paths']['bblayers'] = os.path.join(builddir, "conf/bblayers.conf")
+        self.tc_kwargs['init']['newbuilddir'] = args.newbuilddir
 
         def tag_filter(tags):
             if args.exclude_tags:
diff --git a/poky/meta/lib/oeqa/targetcontrol.py b/poky/meta/lib/oeqa/targetcontrol.py
index 2aa548e..7bbba60 100644
--- a/poky/meta/lib/oeqa/targetcontrol.py
+++ b/poky/meta/lib/oeqa/targetcontrol.py
@@ -182,7 +182,10 @@
         return self.runner.is_alive()
 
     def stop(self):
-        self.runner.stop()
+        try:
+            self.runner.stop()
+        except:
+            pass
         self.logger.removeHandler(self.loggerhandler)
         self.connection = None
         self.ip = None
diff --git a/poky/meta/lib/oeqa/utils/commands.py b/poky/meta/lib/oeqa/utils/commands.py
index f167987..df373c4 100644
--- a/poky/meta/lib/oeqa/utils/commands.py
+++ b/poky/meta/lib/oeqa/utils/commands.py
@@ -351,10 +351,7 @@
 
     finally:
         targetlogger.removeHandler(handler)
-        try:
-            qemu.stop()
-        except:
-            pass
+        qemu.stop()
 
 def updateEnv(env_file):
     """
diff --git a/poky/meta/lib/oeqa/utils/qemurunner.py b/poky/meta/lib/oeqa/utils/qemurunner.py
index 4b74337..992fff9 100644
--- a/poky/meta/lib/oeqa/utils/qemurunner.py
+++ b/poky/meta/lib/oeqa/utils/qemurunner.py
@@ -290,7 +290,7 @@
                 self.logger.debug("qemu cmdline used:\n{}".format(cmdline))
             except (IndexError, ValueError):
                 # Try to get network configuration from runqemu output
-                match = re.match(r'.*Network configuration: ([0-9.]+)::([0-9.]+):([0-9.]+)$.*',
+                match = re.match(r'.*Network configuration: (?:ip=)*([0-9.]+)::([0-9.]+):([0-9.]+)$.*',
                                  out, re.MULTILINE|re.DOTALL)
                 if match:
                     self.ip, self.server_ip, self.netmask = match.groups()
diff --git a/poky/meta/recipes-bsp/u-boot/libubootenv_0.2.bb b/poky/meta/recipes-bsp/u-boot/libubootenv_0.2.bb
index fa90a12..ea29b66 100644
--- a/poky/meta/recipes-bsp/u-boot/libubootenv_0.2.bb
+++ b/poky/meta/recipes-bsp/u-boot/libubootenv_0.2.bb
@@ -1,5 +1,4 @@
 SUMMARY = "U-Boot libraries and tools to access environment"
-DEPENDS += "mtd-utils zlib"
 
 DESCRIPTION = "This package contains tools and libraries to read \
 and modify U-Boot environment. \
@@ -21,6 +20,7 @@
 
 EXTRA_OECMAKE = "-DCMAKE_BUILD_TYPE=Release"
 
+DEPENDS = "zlib"
 PROVIDES += "u-boot-fw-utils"
 RPROVIDES_${PN}-bin += "u-boot-fw-utils"
 
diff --git a/poky/meta/recipes-bsp/u-boot/u-boot.inc b/poky/meta/recipes-bsp/u-boot/u-boot.inc
index 80f828d..6fa2d08 100644
--- a/poky/meta/recipes-bsp/u-boot/u-boot.inc
+++ b/poky/meta/recipes-bsp/u-boot/u-boot.inc
@@ -60,6 +60,10 @@
 UBOOT_ENV_IMAGE ?= "${UBOOT_ENV}-${MACHINE}-${PV}-${PR}.${UBOOT_ENV_SUFFIX}"
 UBOOT_ENV_SYMLINK ?= "${UBOOT_ENV}-${MACHINE}.${UBOOT_ENV_SUFFIX}"
 
+# Default name of u-boot initial env, but enable individual recipes to change
+# this value.
+UBOOT_INITIAL_ENV ?= "${PN}-initial-env"
+
 # U-Boot EXTLINUX variables. U-Boot searches for /boot/extlinux/extlinux.conf
 # to find EXTLINUX conf file.
 UBOOT_EXTLINUX_INSTALL_DIR ?= "/boot/extlinux"
@@ -91,19 +95,19 @@
 }
 
 do_compile () {
-	if [ "${@bb.utils.filter('DISTRO_FEATURES', 'ld-is-gold', d)}" ]; then
-		sed -i 's/$(CROSS_COMPILE)ld$/$(CROSS_COMPILE)ld.bfd/g' ${S}/config.mk
-	fi
+    if [ "${@bb.utils.filter('DISTRO_FEATURES', 'ld-is-gold', d)}" ]; then
+        sed -i 's/$(CROSS_COMPILE)ld$/$(CROSS_COMPILE)ld.bfd/g' ${S}/config.mk
+    fi
 
-	unset LDFLAGS
-	unset CFLAGS
-	unset CPPFLAGS
+    unset LDFLAGS
+    unset CFLAGS
+    unset CPPFLAGS
 
-	if [ ! -e ${B}/.scmversion -a ! -e ${S}/.scmversion ]
-	then
-		echo ${UBOOT_LOCALVERSION} > ${B}/.scmversion
-		echo ${UBOOT_LOCALVERSION} > ${S}/.scmversion
-	fi
+    if [ ! -e ${B}/.scmversion -a ! -e ${S}/.scmversion ]
+    then
+        echo ${UBOOT_LOCALVERSION} > ${B}/.scmversion
+        echo ${UBOOT_LOCALVERSION} > ${S}/.scmversion
+    fi
 
     if [ -n "${UBOOT_CONFIG}" ]
     then
@@ -124,22 +128,25 @@
                     done
 
                     # Generate the uboot-initial-env
-                    oe_runmake -C ${S} O=${B}/${config} u-boot-initial-env
-                    cp ${B}/${config}/u-boot-initial-env ${B}/${config}/u-boot-initial-env-${type}
+                    if [ -n "${UBOOT_INITIAL_ENV}" ]; then
+                        oe_runmake -C ${S} O=${B}/${config} u-boot-initial-env
+                        cp ${B}/${config}/u-boot-initial-env ${B}/${config}/u-boot-initial-env-${type}
+                    fi
 
                     unset k
                 fi
             done
-            unset  j
+            unset j
         done
-        unset  i
+        unset i
     else
         oe_runmake -C ${S} O=${B} ${UBOOT_MAKE_TARGET}
 
         # Generate the uboot-initial-env
-        oe_runmake -C ${S} O=${B} u-boot-initial-env
+        if [ -n "${UBOOT_INITIAL_ENV}" ]; then
+            oe_runmake -C ${S} O=${B} u-boot-initial-env
+        fi
     fi
-
 }
 
 do_install () {
@@ -156,23 +163,27 @@
                     ln -sf u-boot-${type}-${PV}-${PR}.${UBOOT_SUFFIX} ${D}/boot/${UBOOT_BINARY}
 
                     # Install the uboot-initial-env
-                    install -D -m 644 ${B}/${config}/u-boot-initial-env-${type} ${D}/${sysconfdir}/${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR}
-                    ln -sf ${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR} ${D}/${sysconfdir}/${PN}-initial-env-${MACHINE}-${type}
-                    ln -sf ${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR} ${D}/${sysconfdir}/${PN}-initial-env-${type}
-                    ln -sf ${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR} ${D}/${sysconfdir}/${PN}-initial-env
+                    if [ -n "${UBOOT_INITIAL_ENV}" ]; then
+                        install -D -m 644 ${B}/${config}/u-boot-initial-env-${type} ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR}
+                        ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR} ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}-${MACHINE}-${type}
+                        ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR} ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}-${type}
+                        ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR} ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}
+                    fi
                 fi
             done
-            unset  j
+            unset j
         done
-        unset  i
+        unset i
     else
         install -D -m 644 ${B}/${UBOOT_BINARY} ${D}/boot/${UBOOT_IMAGE}
         ln -sf ${UBOOT_IMAGE} ${D}/boot/${UBOOT_BINARY}
 
         # Install the uboot-initial-env
-        install -D -m 644 ${B}/u-boot-initial-env ${D}/${sysconfdir}/${PN}-initial-env-${MACHINE}-${PV}-${PR}
-        ln -sf ${PN}-initial-env-${MACHINE}-${PV}-${PR} ${D}/${sysconfdir}/${PN}-initial-env-${MACHINE}
-        ln -sf ${PN}-initial-env-${MACHINE}-${PV}-${PR} ${D}/${sysconfdir}/${PN}-initial-env
+        if [ -n "${UBOOT_INITIAL_ENV}" ]; then
+            install -D -m 644 ${B}/u-boot-initial-env ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}-${MACHINE}-${PV}-${PR}
+            ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${PV}-${PR} ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}-${MACHINE}
+            ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${PV}-${PR} ${D}/${sysconfdir}/${UBOOT_INITIAL_ENV}
+        fi
     fi
 
     if [ -n "${UBOOT_ELF}" ]
@@ -219,9 +230,9 @@
                          ln -sf ${SPL_IMAGE}-${type}-${PV}-${PR} ${D}/boot/${SPL_BINARYNAME}
                     fi
                 done
-                unset  j
+                unset j
             done
-            unset  i
+            unset i
         else
             install -m 644 ${B}/${SPL_BINARY} ${D}/boot/${SPL_IMAGE}
             ln -sf ${SPL_IMAGE} ${D}/boot/${SPL_BINARYNAME}
@@ -238,14 +249,14 @@
     then
         install -Dm 0644 ${UBOOT_EXTLINUX_CONFIG} ${D}/${UBOOT_EXTLINUX_INSTALL_DIR}/${UBOOT_EXTLINUX_CONF_NAME}
     fi
-
 }
 
 PACKAGE_BEFORE_PN += "${PN}-env"
 
 RPROVIDES_${PN}-env += "u-boot-default-env"
+ALLOW_EMPTY_${PN}-env = "1"
 FILES_${PN}-env = " \
-    ${sysconfdir}/${PN}-initial-env* \
+    ${@ '${sysconfdir}/${UBOOT_INITIAL_ENV}*' if d.getVar('UBOOT_INITIAL_ENV') else ''} \
     ${sysconfdir}/fw_env.config \
 "
 
@@ -269,15 +280,17 @@
                     ln -sf u-boot-${type}-${PV}-${PR}.${UBOOT_SUFFIX} ${UBOOT_BINARY}
 
                     # Deploy the uboot-initial-env
-                    install -D -m 644 ${B}/${config}/u-boot-initial-env-${type} ${DEPLOYDIR}/${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR}
-                    cd ${DEPLOYDIR}
-                    ln -sf ${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR} ${PN}-initial-env-${MACHINE}-${type}
-                    ln -sf ${PN}-initial-env-${MACHINE}-${type}-${PV}-${PR} ${PN}-initial-env-${type}
+                    if [ -n "${UBOOT_INITIAL_ENV}" ]; then
+                        install -D -m 644 ${B}/${config}/u-boot-initial-env-${type} ${DEPLOYDIR}/${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR}
+                        cd ${DEPLOYDIR}
+                        ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR} ${UBOOT_INITIAL_ENV}-${MACHINE}-${type}
+                        ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${type}-${PV}-${PR} ${UBOOT_INITIAL_ENV}-${type}
+                    fi
                 fi
             done
-            unset  j
+            unset j
         done
-        unset  i
+        unset i
     else
         install -D -m 644 ${B}/${UBOOT_BINARY} ${DEPLOYDIR}/${UBOOT_IMAGE}
 
@@ -287,10 +300,12 @@
         ln -sf ${UBOOT_IMAGE} ${UBOOT_BINARY}
 
         # Deploy the uboot-initial-env
-        install -D -m 644 ${B}/u-boot-initial-env ${DEPLOYDIR}/${PN}-initial-env-${MACHINE}-${PV}-${PR}
-        cd ${DEPLOYDIR}
-        ln -sf ${PN}-initial-env-${MACHINE}-${PV}-${PR} ${PN}-initial-env-${MACHINE}
-        ln -sf ${PN}-initial-env-${MACHINE}-${PV}-${PR} ${PN}-initial-env
+        if [ -n "${UBOOT_INITIAL_ENV}" ]; then
+            install -D -m 644 ${B}/u-boot-initial-env ${DEPLOYDIR}/${UBOOT_INITIAL_ENV}-${MACHINE}-${PV}-${PR}
+            cd ${DEPLOYDIR}
+            ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${PV}-${PR} ${UBOOT_INITIAL_ENV}-${MACHINE}
+            ln -sf ${UBOOT_INITIAL_ENV}-${MACHINE}-${PV}-${PR} ${UBOOT_INITIAL_ENV}
+        fi
     fi
 
     if [ -e ${WORKDIR}/fw_env.config ] ; then
@@ -346,9 +361,9 @@
                         ln -sf ${SPL_IMAGE}-${type}-${PV}-${PR} ${DEPLOYDIR}/${SPL_SYMLINK}
                     fi
                 done
-                unset  j
+                unset j
             done
-            unset  i
+            unset i
         else
             install -m 644 ${B}/${SPL_BINARY} ${DEPLOYDIR}/${SPL_IMAGE}
             rm -f ${DEPLOYDIR}/${SPL_BINARYNAME} ${DEPLOYDIR}/${SPL_SYMLINK}
diff --git a/poky/meta/recipes-connectivity/bind/bind/CVE-2020-8616.patch b/poky/meta/recipes-connectivity/bind/bind/CVE-2020-8616.patch
new file mode 100644
index 0000000..8f00231
--- /dev/null
+++ b/poky/meta/recipes-connectivity/bind/bind/CVE-2020-8616.patch
@@ -0,0 +1,206 @@
+Upstream-Status: Backport [https://downloads.isc.org/isc/bind9/9.11.19/patches/CVE-2020-8616.patch]
+CVE: CVE-2020-8616
+Signed-off-by: Lee Chee Yang <chee.yang.lee@intel.com>
+---
+diff --git a/lib/dns/adb.c b/lib/dns/adb.c
+index 058495f6a5..6b8a9537f0 100644
+--- a/lib/dns/adb.c
++++ b/lib/dns/adb.c
+@@ -404,14 +404,13 @@ static void log_quota(dns_adbentry_t *entry, const char *fmt, ...)
+  */
+ #define FIND_WANTEVENT(fn)      (((fn)->options & DNS_ADBFIND_WANTEVENT) != 0)
+ #define FIND_WANTEMPTYEVENT(fn) (((fn)->options & DNS_ADBFIND_EMPTYEVENT) != 0)
+-#define FIND_AVOIDFETCHES(fn)   (((fn)->options & DNS_ADBFIND_AVOIDFETCHES) \
+-				 != 0)
+-#define FIND_STARTATZONE(fn)    (((fn)->options & DNS_ADBFIND_STARTATZONE) \
+-				 != 0)
+-#define FIND_HINTOK(fn)         (((fn)->options & DNS_ADBFIND_HINTOK) != 0)
+-#define FIND_GLUEOK(fn)         (((fn)->options & DNS_ADBFIND_GLUEOK) != 0)
+-#define FIND_HAS_ADDRS(fn)      (!ISC_LIST_EMPTY((fn)->list))
+-#define FIND_RETURNLAME(fn)     (((fn)->options & DNS_ADBFIND_RETURNLAME) != 0)
++#define FIND_AVOIDFETCHES(fn)	(((fn)->options & DNS_ADBFIND_AVOIDFETCHES) != 0)
++#define FIND_STARTATZONE(fn)	(((fn)->options & DNS_ADBFIND_STARTATZONE) != 0)
++#define FIND_HINTOK(fn)		(((fn)->options & DNS_ADBFIND_HINTOK) != 0)
++#define FIND_GLUEOK(fn)		(((fn)->options & DNS_ADBFIND_GLUEOK) != 0)
++#define FIND_HAS_ADDRS(fn)	(!ISC_LIST_EMPTY((fn)->list))
++#define FIND_RETURNLAME(fn)	(((fn)->options & DNS_ADBFIND_RETURNLAME) != 0)
++#define FIND_NOFETCH(fn)	(((fn)->options & DNS_ADBFIND_NOFETCH) != 0)
+ 
+ /*
+  * These are currently used on simple unsigned ints, so they are
+@@ -3155,21 +3154,26 @@ dns_adb_createfind2(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
+ 		 * Listen to negative cache hints, and don't start
+ 		 * another query.
+ 		 */
+-		if (NCACHE_RESULT(result) || AUTH_NX(result))
++		if (NCACHE_RESULT(result) || AUTH_NX(result)) {
+ 			goto fetch;
++		}
+ 
+-		if (!NAME_FETCH_V6(adbname))
++		if (!NAME_FETCH_V6(adbname)) {
+ 			wanted_fetches |= DNS_ADBFIND_INET6;
++		}
+ 	}
+ 
+  fetch:
+ 	if ((WANT_INET(wanted_addresses) && NAME_HAS_V4(adbname)) ||
+ 	    (WANT_INET6(wanted_addresses) && NAME_HAS_V6(adbname)))
++	{
+ 		have_address = true;
+-	else
++	} else {
+ 		have_address = false;
+-	if (wanted_fetches != 0 &&
+-	    ! (FIND_AVOIDFETCHES(find) && have_address)) {
++	}
++	if (wanted_fetches != 0 && !(FIND_AVOIDFETCHES(find) && have_address) &&
++	    !FIND_NOFETCH(find))
++	{
+ 		/*
+ 		 * We're missing at least one address family.  Either the
+ 		 * caller hasn't instructed us to avoid fetches, or we don't
+@@ -3177,8 +3181,9 @@ dns_adb_createfind2(dns_adb_t *adb, isc_task_t *task, isc_taskaction_t action,
+ 		 * be acceptable so we have to launch fetches.
+ 		 */
+ 
+-		if (FIND_STARTATZONE(find))
++		if (FIND_STARTATZONE(find)) {
+ 			start_at_zone = true;
++		}
+ 
+ 		/*
+ 		 * Start V4.
+diff --git a/lib/dns/include/dns/adb.h b/lib/dns/include/dns/adb.h
+index 63a13c4e41..edf6e54935 100644
+--- a/lib/dns/include/dns/adb.h
++++ b/lib/dns/include/dns/adb.h
+@@ -207,6 +207,10 @@ struct dns_adbfind {
+  *      lame for this query.
+  */
+ #define DNS_ADBFIND_OVERQUOTA		0x00000400
++/*%
++ *	Don't perform a fetch even if there are no address records available.
++ */
++#define DNS_ADBFIND_NOFETCH		0x00000800
+ 
+ /*%
+  * The answers to queries come back as a list of these.
+diff --git a/lib/dns/resolver.c b/lib/dns/resolver.c
+index 7c44478a26..0a40859d08 100644
+--- a/lib/dns/resolver.c
++++ b/lib/dns/resolver.c
+@@ -172,6 +172,14 @@
+ #define DEFAULT_MAX_QUERIES 75
+ #endif
+ 
++/*
++ * After NS_FAIL_LIMIT attempts to fetch a name server address,
++ * if the number of addresses in the NS RRset exceeds NS_RR_LIMIT,
++ * stop trying to fetch, in order to avoid wasting resources.
++ */
++#define NS_FAIL_LIMIT 4
++#define NS_RR_LIMIT   5
++
+ /* Number of hash buckets for zone counters */
+ #ifndef RES_DOMAIN_BUCKETS
+ #define RES_DOMAIN_BUCKETS	523
+@@ -3130,8 +3138,7 @@ sort_finds(dns_adbfindlist_t *findlist, unsigned int bias) {
+ static void
+ findname(fetchctx_t *fctx, dns_name_t *name, in_port_t port,
+ 	 unsigned int options, unsigned int flags, isc_stdtime_t now,
+-	 bool *overquota, bool *need_alternate)
+-{
++	 bool *overquota, bool *need_alternate, unsigned int *no_addresses) {
+ 	dns_adbaddrinfo_t *ai;
+ 	dns_adbfind_t *find;
+ 	dns_resolver_t *res;
+@@ -3219,7 +3226,12 @@ findname(fetchctx_t *fctx, dns_name_t *name, in_port_t port,
+ 			      find->result_v6 != DNS_R_NXDOMAIN) ||
+ 			     (res->dispatches6 == NULL &&
+ 			      find->result_v4 != DNS_R_NXDOMAIN)))
++			{
+ 				*need_alternate = true;
++			}
++			if (no_addresses != NULL) {
++				(*no_addresses)++;
++			}
+ 		} else {
+ 			if ((find->options & DNS_ADBFIND_OVERQUOTA) != 0) {
+ 				if (overquota != NULL)
+@@ -3270,6 +3282,7 @@ fctx_getaddresses(fetchctx_t *fctx, bool badcache) {
+ 	dns_rdata_ns_t ns;
+ 	bool need_alternate = false;
+ 	bool all_spilled = true;
++	unsigned int no_addresses = 0;
+ 
+ 	FCTXTRACE5("getaddresses", "fctx->depth=", fctx->depth);
+ 
+@@ -3437,20 +3450,28 @@ fctx_getaddresses(fetchctx_t *fctx, bool badcache) {
+ 		 * Extract the name from the NS record.
+ 		 */
+ 		result = dns_rdata_tostruct(&rdata, &ns, NULL);
+-		if (result != ISC_R_SUCCESS)
++		if (result != ISC_R_SUCCESS) {
+ 			continue;
++		}
+ 
+-		findname(fctx, &ns.name, 0, stdoptions, 0, now,
+-			 &overquota, &need_alternate);
++		if (no_addresses > NS_FAIL_LIMIT &&
++		    dns_rdataset_count(&fctx->nameservers) > NS_RR_LIMIT)
++		{
++			stdoptions |= DNS_ADBFIND_NOFETCH;
++		}
++		findname(fctx, &ns.name, 0, stdoptions, 0, now, &overquota,
++			 &need_alternate, &no_addresses);
+ 
+-		if (!overquota)
++		if (!overquota) {
+ 			all_spilled = false;
++		}
+ 
+ 		dns_rdata_reset(&rdata);
+ 		dns_rdata_freestruct(&ns);
+ 	}
+-	if (result != ISC_R_NOMORE)
++	if (result != ISC_R_NOMORE) {
+ 		return (result);
++	}
+ 
+ 	/*
+ 	 * Do we need to use 6 to 4?
+@@ -3465,7 +3486,7 @@ fctx_getaddresses(fetchctx_t *fctx, bool badcache) {
+ 			if (!a->isaddress) {
+ 				findname(fctx, &a->_u._n.name, a->_u._n.port,
+ 					 stdoptions, FCTX_ADDRINFO_FORWARDER,
+-					 now, NULL, NULL);
++					 now, NULL, NULL, NULL);
+ 				continue;
+ 			}
+ 			if (isc_sockaddr_pf(&a->_u.addr) != family)
+@@ -3827,16 +3827,14 @@ fctx_try(fetchctx_t *fctx, bool retrying, bool badcache) {
+ 		}
+ 	}
+ 
+-	if (dns_name_countlabels(&fctx->domain) > 2) {
+-		result = isc_counter_increment(fctx->qc);
+-		if (result != ISC_R_SUCCESS) {
+-			isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
+-				      DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
+-				      "exceeded max queries resolving '%s'",
+-				      fctx->info);
+-			fctx_done(fctx, DNS_R_SERVFAIL, __LINE__);
+-			return;
+-		}
++	result = isc_counter_increment(fctx->qc);
++	if (result != ISC_R_SUCCESS) {
++		isc_log_write(dns_lctx, DNS_LOGCATEGORY_RESOLVER,
++			      DNS_LOGMODULE_RESOLVER, ISC_LOG_DEBUG(3),
++			      "exceeded max queries resolving '%s'",
++			      fctx->info);
++		fctx_done(fctx, DNS_R_SERVFAIL, __LINE__);
++		return;
+ 	}
+ 
+ 	bucketnum = fctx->bucketnum;
diff --git a/poky/meta/recipes-connectivity/bind/bind/CVE-2020-8617.patch b/poky/meta/recipes-connectivity/bind/bind/CVE-2020-8617.patch
new file mode 100644
index 0000000..d8769c4
--- /dev/null
+++ b/poky/meta/recipes-connectivity/bind/bind/CVE-2020-8617.patch
@@ -0,0 +1,29 @@
+Upstream-Status: Backport [https://downloads.isc.org/isc/bind9/9.11.19/patches/CVE-2020-8617.patch]
+CVE: CVE-2020-8617
+Signed-off-by: Lee Chee Yang <chee.yang.lee@intel.com>
+---
+diff --git a/lib/dns/tsig.c b/lib/dns/tsig.c
+index b597a18d49..6357a3a486 100644
+--- a/lib/dns/tsig.c
++++ b/lib/dns/tsig.c
+@@ -1427,8 +1424,9 @@ dns_tsig_verify(isc_buffer_t *source, dns_message_t *msg,
+ 			goto cleanup_context;
+ 		}
+ 		msg->verified_sig = 1;
+-	} else if (tsig.error != dns_tsigerror_badsig &&
+-		   tsig.error != dns_tsigerror_badkey) {
++	} else if (!response || (tsig.error != dns_tsigerror_badsig &&
++				 tsig.error != dns_tsigerror_badkey))
++	{
+ 		tsig_log(msg->tsigkey, 2, "signature was empty");
+ 		return (DNS_R_TSIGVERIFYFAILURE);
+ 	}
+@@ -1484,7 +1482,7 @@ dns_tsig_verify(isc_buffer_t *source, dns_message_t *msg,
+ 		}
+ 	}
+ 
+-	if (tsig.error != dns_rcode_noerror) {
++	if (response && tsig.error != dns_rcode_noerror) {
+ 		msg->tsigstatus = tsig.error;
+ 		if (tsig.error == dns_tsigerror_badtime)
+ 			ret = DNS_R_CLOCKSKEW;
diff --git a/poky/meta/recipes-connectivity/bind/bind_9.11.13.bb b/poky/meta/recipes-connectivity/bind/bind_9.11.13.bb
index 4e64171..8f2d702 100644
--- a/poky/meta/recipes-connectivity/bind/bind_9.11.13.bb
+++ b/poky/meta/recipes-connectivity/bind/bind_9.11.13.bb
@@ -18,6 +18,8 @@
            file://0001-configure.in-remove-useless-L-use_openssl-lib.patch \
            file://0001-named-lwresd-V-and-start-log-hide-build-options.patch \
            file://0001-avoid-start-failure-with-bind-user.patch \
+           file://CVE-2020-8616.patch \
+           file://CVE-2020-8617.patch \
            "
 
 SRC_URI[md5sum] = "17de0d024ab1eac377f1c2854dc25057"
diff --git a/poky/meta/recipes-connectivity/openssh/openssh_8.2p1.bb b/poky/meta/recipes-connectivity/openssh/openssh_8.3p1.bb
similarity index 97%
rename from poky/meta/recipes-connectivity/openssh/openssh_8.2p1.bb
rename to poky/meta/recipes-connectivity/openssh/openssh_8.3p1.bb
index d879efc..fad3218 100644
--- a/poky/meta/recipes-connectivity/openssh/openssh_8.2p1.bb
+++ b/poky/meta/recipes-connectivity/openssh/openssh_8.3p1.bb
@@ -25,8 +25,7 @@
            file://sshd_check_keys \
            file://add-test-support-for-busybox.patch \
            "
-SRC_URI[md5sum] = "3076e6413e8dbe56d33848c1054ac091"
-SRC_URI[sha256sum] = "43925151e6cf6cee1450190c0e9af4dc36b41c12737619edff8bcebdff64e671"
+SRC_URI[sha256sum] = "f2befbe0472fe7eb75d23340eb17531cb6b3aac24075e2066b41f814e12387b2"
 
 PAM_SRC_URI = "file://sshd"
 
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/0001-Fix-build-with-musl.patch b/poky/meta/recipes-connectivity/ppp/ppp/0001-Fix-build-with-musl.patch
index 763e374..6529136 100644
--- a/poky/meta/recipes-connectivity/ppp/ppp/0001-Fix-build-with-musl.patch
+++ b/poky/meta/recipes-connectivity/ppp/ppp/0001-Fix-build-with-musl.patch
@@ -1,4 +1,4 @@
-From 52a1e41d7541b2c936285844c59bd1be21797860 Mon Sep 17 00:00:00 2001
+From e50cdaed07e51f2508f94eb1f34fe43776e4ca78 Mon Sep 17 00:00:00 2001
 From: Khem Raj <raj.khem@gmail.com>
 Date: Fri, 29 May 2015 14:57:05 -0700
 Subject: [PATCH] Fix build with musl
@@ -6,18 +6,16 @@
 There are several assumption about glibc
 
 Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
 Upstream-Status: Pending
-
+---
  include/net/ppp_defs.h                  | 2 ++
  pppd/Makefile.linux                     | 2 +-
- pppd/magic.h                            | 6 +++---
- pppd/plugins/rp-pppoe/config.h          | 5 ++++-
+ pppd/plugins/rp-pppoe/config.h          | 3 ++-
  pppd/plugins/rp-pppoe/plugin.c          | 1 -
  pppd/plugins/rp-pppoe/pppoe-discovery.c | 8 ++++----
  pppd/plugins/rp-pppoe/pppoe.h           | 2 +-
  pppd/sys-linux.c                        | 3 ++-
- 8 files changed, 17 insertions(+), 12 deletions(-)
+ 7 files changed, 12 insertions(+), 9 deletions(-)
 
 diff --git a/include/net/ppp_defs.h b/include/net/ppp_defs.h
 index b06eda5..dafa36c 100644
@@ -33,11 +31,11 @@
   * The basic PPP frame.
   */
 diff --git a/pppd/Makefile.linux b/pppd/Makefile.linux
-index 8ab2102..d7e2564 100644
+index 4e485a1..76411bc 100644
 --- a/pppd/Makefile.linux
 +++ b/pppd/Makefile.linux
-@@ -126,7 +126,7 @@ LIBS	+= -lcrypt
- #endif
+@@ -131,7 +131,7 @@ LIBS	+= -lcrypt
+ endif
  
  ifdef USE_LIBUTIL
 -CFLAGS	+= -DHAVE_LOGWTMP=1
@@ -45,24 +43,8 @@
  LIBS	+= -lutil
  endif
  
-diff --git a/pppd/magic.h b/pppd/magic.h
-index c81213b..9d399e3 100644
---- a/pppd/magic.h
-+++ b/pppd/magic.h
-@@ -42,8 +42,8 @@
-  * $Id: magic.h,v 1.5 2003/06/11 23:56:26 paulus Exp $
-  */
- 
--void magic_init __P((void));	/* Initialize the magic number generator */
--u_int32_t magic __P((void));	/* Returns the next magic number */
-+void magic_init (void);	/* Initialize the magic number generator */
-+u_int32_t magic (void);	/* Returns the next magic number */
- 
- /* Fill buffer with random bytes */
--void random_bytes __P((unsigned char *buf, int len));
-+void random_bytes (unsigned char *buf, int len);
 diff --git a/pppd/plugins/rp-pppoe/config.h b/pppd/plugins/rp-pppoe/config.h
-index 5703087..fff032e 100644
+index a708859..4a16a88 100644
 --- a/pppd/plugins/rp-pppoe/config.h
 +++ b/pppd/plugins/rp-pppoe/config.h
 @@ -78,8 +78,9 @@
@@ -76,18 +58,8 @@
  /* Define if you have the <net/if.h> header file.  */
  #define HAVE_NET_IF_H 1
  
-@@ -102,7 +103,9 @@
- #define HAVE_NETPACKET_PACKET_H 1
- 
- /* Define if you have the <sys/cdefs.h> header file.  */
-+#ifdef __GLIBC__
- #define HAVE_SYS_CDEFS_H 1
-+#endif
- 
- /* Define if you have the <sys/dlpi.h> header file.  */
- /* #undef HAVE_SYS_DLPI_H */
 diff --git a/pppd/plugins/rp-pppoe/plugin.c b/pppd/plugins/rp-pppoe/plugin.c
-index a8c2bb4..ca34d79 100644
+index 44e0c31..93c0906 100644
 --- a/pppd/plugins/rp-pppoe/plugin.c
 +++ b/pppd/plugins/rp-pppoe/plugin.c
 @@ -46,7 +46,6 @@ static char const RCSID[] =
@@ -99,10 +71,10 @@
  #include <linux/ppp_defs.h>
  #include <linux/if_pppox.h>
 diff --git a/pppd/plugins/rp-pppoe/pppoe-discovery.c b/pppd/plugins/rp-pppoe/pppoe-discovery.c
-index 3d3bf4e..d42f619 100644
+index f19c6d8..f45df2c 100644
 --- a/pppd/plugins/rp-pppoe/pppoe-discovery.c
 +++ b/pppd/plugins/rp-pppoe/pppoe-discovery.c
-@@ -27,10 +27,6 @@
+@@ -29,10 +29,6 @@
  #include <linux/if_packet.h>
  #endif
  
@@ -113,22 +85,11 @@
  #ifdef HAVE_ASM_TYPES_H
  #include <asm/types.h>
  #endif
-@@ -47,6 +43,10 @@
- #include <net/if_arp.h>
- #endif
- 
-+#ifndef __GLIBC__
-+#define error(x...) fprintf(stderr, x)
-+#endif
-+
- char *xstrdup(const char *s);
- void usage(void);
- 
 diff --git a/pppd/plugins/rp-pppoe/pppoe.h b/pppd/plugins/rp-pppoe/pppoe.h
-index 9ab2eee..75b9004 100644
+index a4e7d5c..de191c8 100644
 --- a/pppd/plugins/rp-pppoe/pppoe.h
 +++ b/pppd/plugins/rp-pppoe/pppoe.h
-@@ -92,7 +92,7 @@ typedef unsigned long UINT32_t;
+@@ -90,7 +90,7 @@ typedef unsigned long UINT32_t;
  #ifdef HAVE_SYS_SOCKET_H
  #include <sys/socket.h>
  #endif
@@ -138,7 +99,7 @@
  #endif
  #endif
 diff --git a/pppd/sys-linux.c b/pppd/sys-linux.c
-index a105505..49b0273 100644
+index a0531e9..84ee394 100644
 --- a/pppd/sys-linux.c
 +++ b/pppd/sys-linux.c
 @@ -112,7 +112,7 @@
@@ -159,5 +120,5 @@
  /*
   *    This is in linux/include/net/ipv6.h.
 -- 
-2.1.4
+2.17.1
 
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/0001-ppp-Fix-compilation-errors-in-Makefile.patch b/poky/meta/recipes-connectivity/ppp/ppp/0001-ppp-Fix-compilation-errors-in-Makefile.patch
deleted file mode 100644
index ea4969b..0000000
--- a/poky/meta/recipes-connectivity/ppp/ppp/0001-ppp-Fix-compilation-errors-in-Makefile.patch
+++ /dev/null
@@ -1,30 +0,0 @@
-From ba0f6058d1f25b2b60fc31ab2656bf12a71ffdab Mon Sep 17 00:00:00 2001
-From: Lu Chong <Chong.Lu@windriver.com>
-Date: Tue, 5 Nov 2013 17:32:56 +0800
-Subject: [PATCH] ppp: Fix compilation errors in Makefile
-
-Make can't exit while compilation error occurs in subdir for plugins building.
-
-Upstream-Status: Pending
-
-Signed-off-by: Lu Chong <Chong.Lu@windriver.com>
----
- pppd/plugins/Makefile.linux          |    1 +-
- 1 files changed, 1 insertions(+), 1 deletions(-)
-
-diff --git a/pppd/plugins/Makefile.linux b/pppd/plugins/Makefile.linux
-index 0a7ec7b..2a2c15a 100644
---- a/pppd/plugins/Makefile.linux
-+++ b/pppd/plugins/Makefile.linux
-@@ -20,7 +20,7 @@ include .depend
- endif
- 
- all:	$(PLUGINS)
--	for d in $(SUBDIRS); do $(MAKE) $(MFLAGS) -C $$d all; done
-+	for d in $(SUBDIRS); do $(MAKE) $(MFLAGS) -C $$d all || exit 1; done
- 
- %.so: %.c
- 	$(CC) -o $@ $(LDFLAGS) $(CFLAGS) $^
--- 
-1.7.9.5
-
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/0001-pppoe-include-netinet-in.h-before-linux-in.h.patch b/poky/meta/recipes-connectivity/ppp/ppp/0001-pppoe-include-netinet-in.h-before-linux-in.h.patch
deleted file mode 100644
index 9362d12..0000000
--- a/poky/meta/recipes-connectivity/ppp/ppp/0001-pppoe-include-netinet-in.h-before-linux-in.h.patch
+++ /dev/null
@@ -1,54 +0,0 @@
-From 50a2997b256e0e0ef7a46fae133f56f60fce539c Mon Sep 17 00:00:00 2001
-From: Lubomir Rintel <lkundrak@v3.sk>
-Date: Mon, 9 Jan 2017 13:34:23 +0000
-Subject: [PATCH] pppoe: include netinet/in.h before linux/in.h
-
-This fixes builds with newer kernels. Basically, <netinet/in.h> needs to be
-included before <linux/in.h> otherwise the earlier, unaware of the latter,
-tries to redefine symbols and structures. Also, <linux/if_pppox.h> doesn't work
-alone anymore, since it pulls the headers in the wrong order, so we better
-include <netinet/in.h> early.
-
-Upstream-Status: Backport
-[https://github.com/paulusmack/ppp/commit/50a2997b256e0e0ef7a46fae133f56f60fce539c]
-
-Signed-off-by: Yi Zhao <yi.zhao@windriver.com>
----
- pppd/plugins/rp-pppoe/pppoe.h | 7 ++++---
- 1 file changed, 4 insertions(+), 3 deletions(-)
-
-diff --git a/pppd/plugins/rp-pppoe/pppoe.h b/pppd/plugins/rp-pppoe/pppoe.h
-index 9ab2eee..c4aaa6e 100644
---- a/pppd/plugins/rp-pppoe/pppoe.h
-+++ b/pppd/plugins/rp-pppoe/pppoe.h
-@@ -47,6 +47,10 @@
- #include <sys/socket.h>
- #endif
- 
-+/* This has to be included before Linux 4.8's linux/in.h
-+ * gets dragged in. */
-+#include <netinet/in.h>
-+
- /* Ugly header files on some Linux boxes... */
- #if defined(HAVE_LINUX_IF_H)
- #include <linux/if.h>
-@@ -84,8 +88,6 @@ typedef unsigned long UINT32_t;
- #include <linux/if_ether.h>
- #endif
- 
--#include <netinet/in.h>
--
- #ifdef HAVE_NETINET_IF_ETHER_H
- #include <sys/types.h>
- 
-@@ -98,7 +100,6 @@ typedef unsigned long UINT32_t;
- #endif
- 
- 
--
- /* Ethernet frame types according to RFC 2516 */
- #define ETH_PPPOE_DISCOVERY 0x8863
- #define ETH_PPPOE_SESSION   0x8864
--- 
-2.7.4
-
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/cifdefroute.patch b/poky/meta/recipes-connectivity/ppp/ppp/cifdefroute.patch
deleted file mode 100644
index 7dd69d8..0000000
--- a/poky/meta/recipes-connectivity/ppp/ppp/cifdefroute.patch
+++ /dev/null
@@ -1,297 +0,0 @@
-This patch comes from OpenEmbedded.
-The original patch is from Debian / SuSE to implement replacedefaultroute
-Rebased it to fit ppp-2.4.5. Dongxiao Xu <dongxiao.xu@intel.com>
-
-Upstream-Status: Inappropriate [debian/suse patches]
-
-Index: ppp-2.4.7/pppd/ipcp.c
-===================================================================
---- ppp-2.4.7.orig/pppd/ipcp.c
-+++ ppp-2.4.7/pppd/ipcp.c
-@@ -198,6 +198,16 @@ static option_t ipcp_option_list[] = {
-       "disable defaultroute option", OPT_ALIAS | OPT_A2CLR,
-       &ipcp_wantoptions[0].default_route },
- 
-+#ifdef __linux__
-+    { "replacedefaultroute", o_bool,
-+                               &ipcp_wantoptions[0].replace_default_route,
-+      "Replace default route", 1
-+    },
-+    { "noreplacedefaultroute", o_bool,
-+                               &ipcp_allowoptions[0].replace_default_route,
-+      "Never replace default route", OPT_A2COPY,
-+                               &ipcp_wantoptions[0].replace_default_route },
-+#endif
-     { "proxyarp", o_bool, &ipcp_wantoptions[0].proxy_arp,
-       "Add proxy ARP entry", OPT_ENABLE|1, &ipcp_allowoptions[0].proxy_arp },
-     { "noproxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp,
-@@ -271,7 +281,7 @@ struct protent ipcp_protent = {
-     ip_active_pkt
- };
- 
--static void ipcp_clear_addrs __P((int, u_int32_t, u_int32_t));
-+static void ipcp_clear_addrs __P((int, u_int32_t, u_int32_t, bool));
- static void ipcp_script __P((char *, int));	/* Run an up/down script */
- static void ipcp_script_done __P((void *));
- 
-@@ -1761,7 +1771,12 @@ ip_demand_conf(u)
-     if (!sifnpmode(u, PPP_IP, NPMODE_QUEUE))
- 	return 0;
-     if (wo->default_route)
-+#ifndef __linux__
- 	if (sifdefaultroute(u, wo->ouraddr, wo->hisaddr))
-+#else
-+	if (sifdefaultroute(u, wo->ouraddr, wo->hisaddr,
-+                                            wo->replace_default_route))
-+#endif
- 	    default_route_set[u] = 1;
-     if (wo->proxy_arp)
- 	if (sifproxyarp(u, wo->hisaddr))
-@@ -1849,7 +1864,8 @@ ipcp_up(f)
-      */
-     if (demand) {
- 	if (go->ouraddr != wo->ouraddr || ho->hisaddr != wo->hisaddr) {
--	    ipcp_clear_addrs(f->unit, wo->ouraddr, wo->hisaddr);
-+	    ipcp_clear_addrs(f->unit, wo->ouraddr, wo->hisaddr, 
-+				      wo->replace_default_route);
- 	    if (go->ouraddr != wo->ouraddr) {
- 		warn("Local IP address changed to %I", go->ouraddr);
- 		script_setenv("OLDIPLOCAL", ip_ntoa(wo->ouraddr), 0);
-@@ -1874,7 +1890,12 @@ ipcp_up(f)
- 
- 	    /* assign a default route through the interface if required */
- 	    if (ipcp_wantoptions[f->unit].default_route) 
-+#ifndef __linux__
- 		if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr))
-+#else
-+		if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr,
-+					     wo->replace_default_route))
-+#endif
- 		    default_route_set[f->unit] = 1;
- 
- 	    /* Make a proxy ARP entry if requested. */
-@@ -1924,7 +1945,12 @@ ipcp_up(f)
- 
- 	/* assign a default route through the interface if required */
- 	if (ipcp_wantoptions[f->unit].default_route) 
-+#ifndef __linux__
- 	    if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr))
-+#else
-+	    if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr,
-+					 wo->replace_default_route))
-+#endif
- 		default_route_set[f->unit] = 1;
- 
- 	/* Make a proxy ARP entry if requested. */
-@@ -2002,7 +2028,7 @@ ipcp_down(f)
- 	sifnpmode(f->unit, PPP_IP, NPMODE_DROP);
- 	sifdown(f->unit);
- 	ipcp_clear_addrs(f->unit, ipcp_gotoptions[f->unit].ouraddr,
--			 ipcp_hisoptions[f->unit].hisaddr);
-+			 ipcp_hisoptions[f->unit].hisaddr, 0);
-     }
- 
-     /* Execute the ip-down script */
-@@ -2018,12 +2044,21 @@ ipcp_down(f)
-  * proxy arp entries, etc.
-  */
- static void
--ipcp_clear_addrs(unit, ouraddr, hisaddr)
-+ipcp_clear_addrs(unit, ouraddr, hisaddr, replacedefaultroute)
-     int unit;
-     u_int32_t ouraddr;  /* local address */
-     u_int32_t hisaddr;  /* remote address */
-+    bool replacedefaultroute;
- {
--    if (proxy_arp_set[unit]) {
-+    /* If replacedefaultroute, sifdefaultroute will be called soon
-+     * with replacedefaultroute set and that will overwrite the current
-+     * default route. This is the case only when doing demand, otherwise
-+     * during demand, this cifdefaultroute would restore the old default
-+     * route which is not what we want in this case. In the non-demand
-+     * case, we'll delete the default route and restore the old if there
-+     * is one saved by an sifdefaultroute with replacedefaultroute.
-+     */
-+    if (!replacedefaultroute && default_route_set[unit]) {
- 	cifproxyarp(unit, hisaddr);
- 	proxy_arp_set[unit] = 0;
-     }
-Index: ppp-2.4.7/pppd/ipcp.h
-===================================================================
---- ppp-2.4.7.orig/pppd/ipcp.h
-+++ ppp-2.4.7/pppd/ipcp.h
-@@ -70,6 +70,7 @@ typedef struct ipcp_options {
-     bool old_addrs;		/* Use old (IP-Addresses) option? */
-     bool req_addr;		/* Ask peer to send IP address? */
-     bool default_route;		/* Assign default route through interface? */
-+    bool replace_default_route; /* Replace default route through interface? */
-     bool proxy_arp;		/* Make proxy ARP entry for peer? */
-     bool neg_vj;		/* Van Jacobson Compression? */
-     bool old_vj;		/* use old (short) form of VJ option? */
-Index: ppp-2.4.7/pppd/pppd.8
-===================================================================
---- ppp-2.4.7.orig/pppd/pppd.8
-+++ ppp-2.4.7/pppd/pppd.8
-@@ -121,6 +121,13 @@ the gateway, when IPCP negotiation is su
- This entry is removed when the PPP connection is broken.  This option
- is privileged if the \fInodefaultroute\fR option has been specified.
- .TP
-+.B replacedefaultroute
-+This option is a flag to the defaultroute option. If defaultroute is
-+set and this flag is also set, pppd replaces an existing default route
-+with the new default route.
-+
-+
-+.TP
- .B disconnect \fIscript
- Execute the command specified by \fIscript\fR, by passing it to a
- shell, after
-@@ -734,7 +741,12 @@ disable both forms of hardware flow cont
- .TP
- .B nodefaultroute
- Disable the \fIdefaultroute\fR option.  The system administrator who
--wishes to prevent users from creating default routes with pppd
-+wishes to prevent users from adding a default route with pppd
-+can do so by placing this option in the /etc/ppp/options file.
-+.TP
-+.B noreplacedefaultroute
-+Disable the \fIreplacedefaultroute\fR option. The system administrator who
-+wishes to prevent users from replacing a default route with pppd
- can do so by placing this option in the /etc/ppp/options file.
- .TP
- .B nodeflate
-Index: ppp-2.4.7/pppd/pppd.h
-===================================================================
---- ppp-2.4.7.orig/pppd/pppd.h
-+++ ppp-2.4.7/pppd/pppd.h
-@@ -665,7 +665,11 @@ int  sif6addr __P((int, eui64_t, eui64_t
- int  cif6addr __P((int, eui64_t, eui64_t));
- 				/* Remove an IPv6 address from i/f */
- #endif
-+#ifndef __linux__
- int  sifdefaultroute __P((int, u_int32_t, u_int32_t));
-+#else
-+int  sifdefaultroute __P((int, u_int32_t, u_int32_t, bool replace_default_rt));
-+#endif
- 				/* Create default route through i/f */
- int  cifdefaultroute __P((int, u_int32_t, u_int32_t));
- 				/* Delete default route through i/f */
-Index: ppp-2.4.7/pppd/sys-linux.c
-===================================================================
---- ppp-2.4.7.orig/pppd/sys-linux.c
-+++ ppp-2.4.7/pppd/sys-linux.c
-@@ -207,6 +207,8 @@ static unsigned char inbuf[512]; /* buff
- static int	if_is_up;	/* Interface has been marked up */
- static int	if6_is_up;	/* Interface has been marked up for IPv6, to help differentiate */
- static int	have_default_route;	/* Gateway for default route added */
-+static struct rtentry old_def_rt;       /* Old default route */
-+static int       default_rt_repl_rest;  /* replace and restore old default rt */
- static u_int32_t proxy_arp_addr;	/* Addr for proxy arp entry added */
- static char proxy_arp_dev[16];		/* Device for proxy arp entry */
- static u_int32_t our_old_addr;		/* for detecting address changes */
-@@ -1545,6 +1547,9 @@ static int read_route_table(struct rtent
- 	p = NULL;
-     }
- 
-+    SET_SA_FAMILY (rt->rt_dst,     AF_INET);
-+    SET_SA_FAMILY (rt->rt_gateway, AF_INET);
-+
-     SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
-     SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
-     SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
-@@ -1614,20 +1619,51 @@ int have_route_to(u_int32_t addr)
- /********************************************************************
-  *
-  * sifdefaultroute - assign a default route through the address given.
-- */
--
--int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
--{
--    struct rtentry rt;
--
--    if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
--	if (rt.rt_flags & RTF_GATEWAY)
--	    error("not replacing existing default route via %I",
--		  SIN_ADDR(rt.rt_gateway));
--	else
--	    error("not replacing existing default route through %s",
--		  rt.rt_dev);
--	return 0;
-+ *
-+ * If the global default_rt_repl_rest flag is set, then this function
-+ * already replaced the original system defaultroute with some other
-+ * route and it should just replace the current defaultroute with
-+ * another one, without saving the current route. Use: demand mode,
-+ * when pppd sets first a defaultroute it it's temporary ppp0 addresses
-+ * and then changes the temporary addresses to the addresses for the real
-+ * ppp connection when it has come up.
-+ */
-+
-+int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway, bool replace)
-+{
-+    struct rtentry rt, tmp_rt;
-+    struct rtentry *del_rt = NULL;
-+
-+    if (default_rt_repl_rest) {
-+	/* We have already reclaced the original defaultroute, if we
-+         * are called again, we will delete the current default route
-+         * and set the new default route in this function.  
-+         * - this is normally only the case the doing demand: */
-+	if (defaultroute_exists( &tmp_rt ))
-+		del_rt = &tmp_rt;
-+    } else if ( defaultroute_exists( &old_def_rt                ) &&
-+	                     strcmp(  old_def_rt.rt_dev, ifname ) != 0) {
-+	/* We did not yet replace an existing default route, let's
-+	 * check if we should save and replace a default route:
-+         */
-+	u_int32_t old_gateway = SIN_ADDR(old_def_rt.rt_gateway);
-+	if (old_gateway != gateway) {
-+	    if (!replace) {
-+	        error("not replacing default route to %s [%I]",
-+			old_def_rt.rt_dev, old_gateway);
-+		return 0;
-+	    } else {
-+		// we need to copy rt_dev because we need it permanent too:
-+		char * tmp_dev = malloc(strlen(old_def_rt.rt_dev)+1);
-+		strcpy(tmp_dev, old_def_rt.rt_dev);
-+		old_def_rt.rt_dev = tmp_dev;
-+
-+		notice("replacing old default route to %s [%I]",
-+			old_def_rt.rt_dev, old_gateway);
-+	        default_rt_repl_rest = 1;
-+		del_rt = &old_def_rt;
-+	    }
-+	}
-     }
- 
-     memset (&rt, 0, sizeof (rt));
-@@ -1646,6 +1682,12 @@ int sifdefaultroute (int unit, u_int32_t
- 	    error("default route ioctl(SIOCADDRT): %m");
- 	return 0;
-     }
-+    if (default_rt_repl_rest && del_rt)
-+        if (ioctl(sock_fd, SIOCDELRT, del_rt) < 0) {
-+	    if ( ! ok_error ( errno ))
-+	        error("del old default route ioctl(SIOCDELRT): %m(%d)", errno);
-+	    return 0;
-+        }
- 
-     have_default_route = 1;
-     return 1;
-@@ -1681,6 +1723,16 @@ int cifdefaultroute (int unit, u_int32_t
- 	    return 0;
- 	}
-     }
-+    if (default_rt_repl_rest) {
-+	notice("restoring old default route to %s [%I]",
-+			old_def_rt.rt_dev, SIN_ADDR(old_def_rt.rt_gateway));
-+        if (ioctl(sock_fd, SIOCADDRT, &old_def_rt) < 0) {
-+	    if ( ! ok_error ( errno ))
-+	        error("restore default route ioctl(SIOCADDRT): %m(%d)", errno);
-+	    return 0;
-+        }
-+        default_rt_repl_rest = 0;
-+    }
- 
-     return 1;
- }
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/makefile-remove-hard-usr-reference.patch b/poky/meta/recipes-connectivity/ppp/ppp/makefile-remove-hard-usr-reference.patch
index 8a69396..614a474 100644
--- a/poky/meta/recipes-connectivity/ppp/ppp/makefile-remove-hard-usr-reference.patch
+++ b/poky/meta/recipes-connectivity/ppp/ppp/makefile-remove-hard-usr-reference.patch
@@ -1,3 +1,8 @@
+From 505705d0e1b55ce3fdc10d0e5eab5488f869adb6 Mon Sep 17 00:00:00 2001
+From: Andreas Oberritter <obi@opendreambox.org>
+Date: Thu, 1 Jul 2010 14:34:12 +0800
+Subject: [PATCH] ppp: Upgraded to version 2.4.5
+
 The patch comes from OpenEmbedded.
 Rebased for ppp-2.4.5. Dongxiao Xu <dongxiao.xu@intel.com>
 
@@ -6,24 +11,15 @@
 
 Upstream-Status: Inappropriate [configuration]
 
-Index: ppp-2.4.7/pppd/Makefile.linux
-===================================================================
---- ppp-2.4.7.orig/pppd/Makefile.linux
-+++ ppp-2.4.7/pppd/Makefile.linux
-@@ -120,10 +120,10 @@ CFLAGS   += -DHAS_SHADOW
- #LIBS     += -lshadow $(LIBS)
- endif
- 
--ifneq ($(wildcard /usr/include/crypt.h),)
-+#ifneq ($(wildcard /usr/include/crypt.h),)
- CFLAGS  += -DHAVE_CRYPT_H=1
- LIBS	+= -lcrypt
--endif
-+#endif
- 
- ifdef USE_LIBUTIL
- CFLAGS	+= -DHAVE_LOGWTMP=1
-@@ -177,10 +177,10 @@ LIBS	+= -ldl
+---
+ pppd/Makefile.linux | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/pppd/Makefile.linux b/pppd/Makefile.linux
+index 4e485a1..44c4193 100644
+--- a/pppd/Makefile.linux
++++ b/pppd/Makefile.linux
+@@ -188,10 +188,10 @@ LIBS	+= -ldl
  endif
  
  ifdef FILTER
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/makefile.patch b/poky/meta/recipes-connectivity/ppp/ppp/makefile.patch
index 2d09baf..25b8ded 100644
--- a/poky/meta/recipes-connectivity/ppp/ppp/makefile.patch
+++ b/poky/meta/recipes-connectivity/ppp/ppp/makefile.patch
@@ -1,12 +1,27 @@
+From f7fb1d1abfa6d208fb40fca1602e0c488108f1b5 Mon Sep 17 00:00:00 2001
+From: Richard Purdie <richard@openedhand.com>
+Date: Wed, 31 Aug 2005 10:45:47 +0000
+Subject: [PATCH] Initial population
+
 The patch comes from OpenEmbedded
 Rebased for ppp-2.4.5. Dongxiao Xu <dongxiao.xu@intel.com>
 
 Upstream-Status: Inappropriate [configuration]
 
-diff -ruN ppp-2.4.5-orig/chat/Makefile.linux ppp-2.4.5/chat/Makefile.linux
---- ppp-2.4.5-orig/chat/Makefile.linux	2010-06-30 15:51:12.050166398 +0800
-+++ ppp-2.4.5/chat/Makefile.linux	2010-06-30 15:51:30.450118446 +0800
-@@ -25,7 +25,7 @@
+---
+ chat/Makefile.linux                  |  2 +-
+ pppd/Makefile.linux                  |  4 ++--
+ pppd/plugins/radius/Makefile.linux   | 10 +++++-----
+ pppd/plugins/rp-pppoe/Makefile.linux |  4 ++--
+ pppdump/Makefile.linux               |  2 +-
+ pppstats/Makefile.linux              |  2 +-
+ 6 files changed, 12 insertions(+), 12 deletions(-)
+
+diff --git a/chat/Makefile.linux b/chat/Makefile.linux
+index 0732ec8..f082dab 100644
+--- a/chat/Makefile.linux
++++ b/chat/Makefile.linux
+@@ -25,7 +25,7 @@ chat.o:	chat.c
  
  install: chat
  	mkdir -p $(BINDIR) $(MANDIR)
@@ -15,10 +30,11 @@
  	$(INSTALL) -c -m 644 chat.8 $(MANDIR)
  
  clean:
-diff -ruN ppp-2.4.5-orig/pppd/Makefile.linux ppp-2.4.5/pppd/Makefile.linux
---- ppp-2.4.5-orig/pppd/Makefile.linux	2010-06-30 15:51:12.043682063 +0800
-+++ ppp-2.4.5/pppd/Makefile.linux	2010-06-30 15:52:11.214170607 +0800
-@@ -99,7 +99,7 @@
+diff --git a/pppd/Makefile.linux b/pppd/Makefile.linux
+index 9664f70..4e485a1 100644
+--- a/pppd/Makefile.linux
++++ b/pppd/Makefile.linux
+@@ -107,7 +107,7 @@ ifdef USE_SRP
  CFLAGS	+= -DUSE_SRP -DOPENSSL -I/usr/local/ssl/include
  LIBS	+= -lsrp -L/usr/local/ssl/lib -lcrypto
  TARGETS	+= srp-entry
@@ -27,7 +43,7 @@
  MANPAGES += srp-entry.8
  EXTRACLEAN += srp-entry.o
  NEEDDES=y
-@@ -200,7 +200,7 @@
+@@ -219,7 +219,7 @@ all: $(TARGETS)
  install: pppd
  	mkdir -p $(BINDIR) $(MANDIR)
  	$(EXTRAINSTALL)
@@ -36,10 +52,11 @@
  	if chgrp pppusers $(BINDIR)/pppd 2>/dev/null; then \
  	  chmod o-rx,u+s $(BINDIR)/pppd; fi
  	$(INSTALL) -c -m 444 pppd.8 $(MANDIR)
-diff -ruN ppp-2.4.5-orig/pppd/plugins/radius/Makefile.linux ppp-2.4.5/pppd/plugins/radius/Makefile.linux
---- ppp-2.4.5-orig/pppd/plugins/radius/Makefile.linux	2010-06-30 15:51:12.047676187 +0800
-+++ ppp-2.4.5/pppd/plugins/radius/Makefile.linux	2010-06-30 15:53:47.750182267 +0800
-@@ -36,11 +36,11 @@
+diff --git a/pppd/plugins/radius/Makefile.linux b/pppd/plugins/radius/Makefile.linux
+index e702263..af57ae3 100644
+--- a/pppd/plugins/radius/Makefile.linux
++++ b/pppd/plugins/radius/Makefile.linux
+@@ -36,11 +36,11 @@ all: $(PLUGIN)
  
  install: all
  	$(INSTALL) -d -m 755 $(LIBDIR)
@@ -55,11 +72,12 @@
 +	$(INSTALL) -m 444 pppd-radattr.8 $(MANDIR)
  
  radius.so: radius.o libradiusclient.a
- 	$(CC) -o radius.so -shared radius.o libradiusclient.a
-diff -ruN ppp-2.4.5-orig/pppd/plugins/rp-pppoe/Makefile.linux ppp-2.4.5/pppd/plugins/rp-pppoe/Makefile.linux
---- ppp-2.4.5-orig/pppd/plugins/rp-pppoe/Makefile.linux	2010-06-30 15:51:12.047676187 +0800
-+++ ppp-2.4.5/pppd/plugins/rp-pppoe/Makefile.linux	2010-06-30 15:53:15.454486877 +0800
-@@ -43,9 +43,9 @@
+ 	$(CC) $(LDFLAGS) -o radius.so -shared radius.o libradiusclient.a
+diff --git a/pppd/plugins/rp-pppoe/Makefile.linux b/pppd/plugins/rp-pppoe/Makefile.linux
+index 749ccc2..2c93f4a 100644
+--- a/pppd/plugins/rp-pppoe/Makefile.linux
++++ b/pppd/plugins/rp-pppoe/Makefile.linux
+@@ -43,9 +43,9 @@ rp-pppoe.so: plugin.o discovery.o if.o common.o
  
  install: all
  	$(INSTALL) -d -m 755 $(LIBDIR)
@@ -71,20 +89,22 @@
  
  clean:
  	rm -f *.o *.so pppoe-discovery
-diff -ruN ppp-2.4.5-orig/pppdump/Makefile.linux ppp-2.4.5/pppdump/Makefile.linux
---- ppp-2.4.5-orig/pppdump/Makefile.linux	2010-06-30 15:51:12.058183383 +0800
-+++ ppp-2.4.5/pppdump/Makefile.linux	2010-06-30 15:52:25.762183537 +0800
-@@ -17,5 +17,5 @@
+diff --git a/pppdump/Makefile.linux b/pppdump/Makefile.linux
+index cdf7ac4..0457561 100644
+--- a/pppdump/Makefile.linux
++++ b/pppdump/Makefile.linux
+@@ -17,5 +17,5 @@ clean:
  
  install:
  	mkdir -p $(BINDIR) $(MANDIR)
 -	$(INSTALL) -s -c pppdump $(BINDIR)
 +	$(INSTALL) -c pppdump $(BINDIR)
  	$(INSTALL) -c -m 444 pppdump.8 $(MANDIR)
-diff -ruN ppp-2.4.5-orig/pppstats/Makefile.linux ppp-2.4.5/pppstats/Makefile.linux
---- ppp-2.4.5-orig/pppstats/Makefile.linux	2010-06-30 15:51:12.058183383 +0800
-+++ ppp-2.4.5/pppstats/Makefile.linux	2010-06-30 15:52:42.486341081 +0800
-@@ -22,7 +22,7 @@
+diff --git a/pppstats/Makefile.linux b/pppstats/Makefile.linux
+index 71afbe6..1819370 100644
+--- a/pppstats/Makefile.linux
++++ b/pppstats/Makefile.linux
+@@ -22,7 +22,7 @@ all: pppstats
  
  install: pppstats
  	-mkdir -p $(MANDIR)
diff --git a/poky/meta/recipes-connectivity/ppp/ppp/ppp-2.4.7-DES-openssl.patch b/poky/meta/recipes-connectivity/ppp/ppp/ppp-2.4.7-DES-openssl.patch
deleted file mode 100644
index e53f240..0000000
--- a/poky/meta/recipes-connectivity/ppp/ppp/ppp-2.4.7-DES-openssl.patch
+++ /dev/null
@@ -1,84 +0,0 @@
-Used openssl for the DES instead of the libcrypt / glibc
-
-Upstream-Status: Pending
-
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
-
-Index: ppp-2.4.7/pppd/Makefile.linux
-===================================================================
---- ppp-2.4.7.orig/pppd/Makefile.linux
-+++ ppp-2.4.7/pppd/Makefile.linux
-@@ -38,7 +38,7 @@ LIBS =
- # Uncomment the next 2 lines to include support for Microsoft's
- # MS-CHAP authentication protocol.  Also, edit plugins/radius/Makefile.linux.
- CHAPMS=y
--USE_CRYPT=y
-+#USE_CRYPT=y
- # Don't use MSLANMAN unless you really know what you're doing.
- #MSLANMAN=y
- # Uncomment the next line to include support for MPPE.  CHAPMS (above) must
-@@ -132,7 +132,7 @@ endif
- 
- ifdef NEEDDES
- ifndef USE_CRYPT
--LIBS     += -ldes $(LIBS)
-+LIBS     += -lcrypto
- else
- CFLAGS   += -DUSE_CRYPT=1
- endif
-Index: ppp-2.4.7/pppd/pppcrypt.c
-===================================================================
---- ppp-2.4.7.orig/pppd/pppcrypt.c
-+++ ppp-2.4.7/pppd/pppcrypt.c
-@@ -64,7 +64,7 @@ u_char *des_key;	/* OUT 64 bit DES key w
- 	des_key[7] = Get7Bits(key, 49);
- 
- #ifndef USE_CRYPT
--	des_set_odd_parity((des_cblock *)des_key);
-+	DES_set_odd_parity((DES_cblock *)des_key);
- #endif
- }
- 
-@@ -158,25 +158,25 @@ u_char *clear;	/* OUT 8 octets */
- }
- 
- #else /* USE_CRYPT */
--static des_key_schedule	key_schedule;
-+static DES_key_schedule	key_schedule;
- 
- bool
- DesSetkey(key)
- u_char *key;
- {
--	des_cblock des_key;
-+	DES_cblock des_key;
- 	MakeKey(key, des_key);
--	des_set_key(&des_key, key_schedule);
-+	DES_set_key(&des_key, &key_schedule);
- 	return (1);
- }
- 
- bool
--DesEncrypt(clear, key, cipher)
-+DesEncrypt(clear, cipher)
- u_char *clear;	/* IN  8 octets */
- u_char *cipher;	/* OUT 8 octets */
- {
--	des_ecb_encrypt((des_cblock *)clear, (des_cblock *)cipher,
--	    key_schedule, 1);
-+	DES_ecb_encrypt((DES_cblock *)clear, (DES_cblock *)cipher,
-+	    &key_schedule, 1);
- 	return (1);
- }
- 
-@@ -185,8 +185,8 @@ DesDecrypt(cipher, clear)
- u_char *cipher;	/* IN  8 octets */
- u_char *clear;	/* OUT 8 octets */
- {
--	des_ecb_encrypt((des_cblock *)cipher, (des_cblock *)clear,
--	    key_schedule, 0);
-+	DES_ecb_encrypt((DES_cblock *)cipher, (DES_cblock *)clear,
-+	    &key_schedule, 0);
- 	return (1);
- }
- 
diff --git a/poky/meta/recipes-connectivity/ppp/ppp_2.4.7.bb b/poky/meta/recipes-connectivity/ppp/ppp_2.4.8.bb
similarity index 92%
rename from poky/meta/recipes-connectivity/ppp/ppp_2.4.7.bb
rename to poky/meta/recipes-connectivity/ppp/ppp_2.4.8.bb
index 60c56dd..f9c60d6 100644
--- a/poky/meta/recipes-connectivity/ppp/ppp_2.4.7.bb
+++ b/poky/meta/recipes-connectivity/ppp/ppp_2.4.8.bb
@@ -13,7 +13,6 @@
 
 SRC_URI = "https://download.samba.org/pub/${BPN}/${BP}.tar.gz \
            file://makefile.patch \
-           file://cifdefroute.patch \
            file://pppd-resolv-varrun.patch \
            file://makefile-remove-hard-usr-reference.patch \
            file://pon \
@@ -27,20 +26,17 @@
            file://pap \
            file://ppp_on_boot \
            file://provider \
-           file://0001-ppp-Fix-compilation-errors-in-Makefile.patch \
            file://ppp@.service \
            file://fix-CVE-2015-3310.patch \
-           file://0001-pppoe-include-netinet-in.h-before-linux-in.h.patch \
            file://0001-ppp-Remove-unneeded-include.patch \
-           file://ppp-2.4.7-DES-openssl.patch \
            file://0001-pppd-Fix-bounds-check-in-EAP-code.patch \
-"
+           "
 
 SRC_URI_append_libc-musl = "\
            file://0001-Fix-build-with-musl.patch \
 "
-SRC_URI[md5sum] = "78818f40e6d33a1d1de68a1551f6595a"
-SRC_URI[sha256sum] = "02e0a3dd3e4799e33103f70ec7df75348c8540966ee7c948e4ed8a42bbccfb30"
+SRC_URI[md5sum] = "2ca8342b9804be15103fd3f687af701c"
+SRC_URI[sha256sum] = "f6bf89beae26b2943dff8f1003533d6a5a4909a0fa6edfbec44fe039bbe61bc6"
 
 inherit autotools-brokensep systemd
 
diff --git a/poky/meta/recipes-core/dbus/dbus-test_1.12.16.bb b/poky/meta/recipes-core/dbus/dbus-test_1.12.18.bb
similarity index 95%
rename from poky/meta/recipes-core/dbus/dbus-test_1.12.16.bb
rename to poky/meta/recipes-core/dbus/dbus-test_1.12.18.bb
index bea0e74..0063dcc 100644
--- a/poky/meta/recipes-core/dbus/dbus-test_1.12.16.bb
+++ b/poky/meta/recipes-core/dbus/dbus-test_1.12.18.bb
@@ -16,8 +16,8 @@
            file://clear-guid_from_server-if-send_negotiate_unix_f.patch \
            "
 
-SRC_URI[md5sum] = "2dbeae80dfc9e3632320c6a53d5e8890"
-SRC_URI[sha256sum] = "54a22d2fa42f2eb2a871f32811c6005b531b9613b1b93a0d269b05e7549fec80"
+SRC_URI[md5sum] = "4ca570c281be35d0b30ab83436712242"
+SRC_URI[sha256sum] = "64cf4d70840230e5e9bc784d153880775ab3db19d656ead8a0cb9c0ab5a95306"
 
 S="${WORKDIR}/dbus-${PV}"
 FILESEXTRAPATHS =. "${FILE_DIRNAME}/dbus:"
diff --git a/poky/meta/recipes-core/dbus/dbus_1.12.16.bb b/poky/meta/recipes-core/dbus/dbus_1.12.18.bb
similarity index 97%
rename from poky/meta/recipes-core/dbus/dbus_1.12.16.bb
rename to poky/meta/recipes-core/dbus/dbus_1.12.18.bb
index 82bb753..2fcb307 100644
--- a/poky/meta/recipes-core/dbus/dbus_1.12.16.bb
+++ b/poky/meta/recipes-core/dbus/dbus_1.12.18.bb
@@ -18,8 +18,8 @@
            file://clear-guid_from_server-if-send_negotiate_unix_f.patch \
 "
 
-SRC_URI[md5sum] = "2dbeae80dfc9e3632320c6a53d5e8890"
-SRC_URI[sha256sum] = "54a22d2fa42f2eb2a871f32811c6005b531b9613b1b93a0d269b05e7549fec80"
+SRC_URI[md5sum] = "4ca570c281be35d0b30ab83436712242"
+SRC_URI[sha256sum] = "64cf4d70840230e5e9bc784d153880775ab3db19d656ead8a0cb9c0ab5a95306"
 
 inherit useradd autotools pkgconfig gettext update-rc.d upstream-version-is-even
 
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/0001-msgmerge-Fix-behaviour-of-for-msgfmt-on-PO-files-wit.patch b/poky/meta/recipes-core/gettext/gettext-0.20.1/0001-msgmerge-Fix-behaviour-of-for-msgfmt-on-PO-files-wit.patch
deleted file mode 100644
index 2245889..0000000
--- a/poky/meta/recipes-core/gettext/gettext-0.20.1/0001-msgmerge-Fix-behaviour-of-for-msgfmt-on-PO-files-wit.patch
+++ /dev/null
@@ -1,87 +0,0 @@
-From 75e315fdec82d1a17ebcd9e0712d109323578d68 Mon Sep 17 00:00:00 2001
-From: Bruno Haible <bruno@clisp.org>
-Date: Sun, 19 May 2019 11:10:06 +0200
-Subject: [PATCH] msgmerge: Fix behaviour of --for-msgfmt on PO files with no
- translations.
-
-msgmerge: Fix behaviour of --for-msgfmt on PO files with no translations.
-
-Reported by Don Lawrence <dlawrence@iecok.com>
-in <https://lists.freedesktop.org/archives/p11-glue/2019-May/000700.html>
-via Daiki Ueno
-in <https://lists.gnu.org/archive/html/bug-gettext/2019-05/msg00124.html>.
-
-* gettext-tools/src/msgmerge.c (main): Treat force_po like true if for_msgfmt
-is true.
-* gettext-tools/tests/msgmerge-26: Add test of PO file with no translations.
-
-Upstream-Status: Backport [https://git.savannah.gnu.org/gitweb/?p=gettext.git;a=commitdiff;h=2336451ed68d91ff4b5ae1acbc1eca30e47a86a9]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- gettext-tools/src/msgmerge.c    |  4 ++--
- gettext-tools/tests/msgmerge-26 | 36 ++++++++++++++++++++++++++++++---
- 2 files changed, 35 insertions(+), 5 deletions(-)
-
-diff --git a/gettext-tools/src/msgmerge.c b/gettext-tools/src/msgmerge.c
-index cd762c0..92c9b7a 100644
---- a/gettext-tools/src/msgmerge.c
-+++ b/gettext-tools/src/msgmerge.c
-@@ -520,8 +520,8 @@ There is NO WARRANTY, to the extent permitted by law.\n\
-   else
-     {
-       /* Write the merged message list out.  */
--      msgdomain_list_print (result, output_file, output_syntax, force_po,
--                            false);
-+      msgdomain_list_print (result, output_file, output_syntax,
-+                            for_msgfmt || force_po, false);
-     }
- 
-   exit (EXIT_SUCCESS);
-diff --git a/gettext-tools/tests/msgmerge-26 b/gettext-tools/tests/msgmerge-26
-index cd3862e..b86f7a0 100755
---- a/gettext-tools/tests/msgmerge-26
-+++ b/gettext-tools/tests/msgmerge-26
-@@ -73,7 +73,37 @@ msgstr "Papaya"
- EOF
- 
- : ${DIFF=diff}
--${DIFF} mm-test26.ok mm-test26.out
--result=$?
-+${DIFF} mm-test26.ok mm-test26.out || Exit 1
- 
--exit $result
-+# Test with a PO file that has no translated messages.
-+
-+cat <<\EOF > mm-test26a.in1
-+msgid ""
-+msgstr ""
-+"Content-Type: text/plain; charset=UTF-8\n"
-+
-+msgid "Hello world"
-+msgstr "Hallo Welt"
-+EOF
-+
-+cat <<\EOF > mm-test26a.in2
-+msgid ""
-+msgstr ""
-+"Content-Type: text/plain; charset=ASCII\n"
-+
-+msgid "Hello, world!"
-+msgstr ""
-+EOF
-+
-+: ${MSGMERGE=msgmerge}
-+${MSGMERGE} --for-msgfmt -o mm-test26a.tmp mm-test26a.in1 mm-test26a.in2 \
-+    || Exit 1
-+LC_ALL=C tr -d '\r' < mm-test26a.tmp > mm-test26a.out || Exit 1
-+
-+cat <<\EOF > mm-test26a.ok
-+msgid ""
-+msgstr "Content-Type: text/plain; charset=UTF-8\n"
-+EOF
-+
-+: ${DIFF=diff}
-+${DIFF} mm-test26a.ok mm-test26a.out || Exit 1
--- 
-2.24.1
-
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/cr-statement.c-timsort.h-fix-formatting-issues.patch b/poky/meta/recipes-core/gettext/gettext-0.20.1/cr-statement.c-timsort.h-fix-formatting-issues.patch
deleted file mode 100644
index 0561ed7..0000000
--- a/poky/meta/recipes-core/gettext/gettext-0.20.1/cr-statement.c-timsort.h-fix-formatting-issues.patch
+++ /dev/null
@@ -1,71 +0,0 @@
-From f6245ef5530fc37a6243e798df34162fbbeab6f0 Mon Sep 17 00:00:00 2001
-From: Robert Yang <liezhi.yang@windriver.com>
-Date: Sun, 19 Feb 2017 23:32:46 -0800
-Subject: [PATCH] cr-statement.c/timsort.h: fix formatting issues
-
-Fixed when compile with "-Wformat -Wformat-security -Werror=format-security":
-| gettext-tools/gnulib-lib/libcroco/cr-statement.c: In function 'cr_statement_dump_charset':
-| gettext-tools/gnulib-lib/libcroco/cr-statement.c:2661:17: error: format not a string literal and no format arguments [-Werror=format-security]
-|                  fprintf (a_fp, str) ;
-
-And:
-gettext-tools/gnulib-lib/libxml/timsort.h:326:80: warning: format '%lu' expects argument of type 'long unsigned int', but argument 3 has type 'unsigned int' [-Wformat=]
-       fprintf(stderr, "Error allocating temporary storage for tim sort: need %lu bytes", sizeof(SORT_TYPE) * new_size);
-
-Upstream-Status: Pending
-
-Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
-
----
- libtextstyle/lib/libcroco/cr-statement.c | 10 +++++-----
- 1 file changed, 5 insertions(+), 5 deletions(-)
-
-diff --git a/libtextstyle/lib/libcroco/cr-statement.c b/libtextstyle/lib/libcroco/cr-statement.c
-index 617520f..100104b 100644
---- a/libtextstyle/lib/libcroco/cr-statement.c
-+++ b/libtextstyle/lib/libcroco/cr-statement.c
-@@ -2607,7 +2607,7 @@ cr_statement_dump_ruleset (CRStatement * a_this, FILE * a_fp, glong a_indent)
-         g_return_if_fail (a_fp && a_this);
-         str = cr_statement_ruleset_to_string (a_this, a_indent);
-         if (str) {
--                fprintf (a_fp, str);
-+                fprintf (a_fp, "%s", str);
-                 g_free (str);
-                 str = NULL;
-         }
-@@ -2658,7 +2658,7 @@ cr_statement_dump_charset (CRStatement * a_this, FILE * a_fp, gulong a_indent)
-         str = cr_statement_charset_to_string (a_this,
-                                               a_indent) ;
-         if (str) {
--                fprintf (a_fp, str) ;
-+                fprintf (a_fp, "%s", str) ;
-                 g_free (str) ;
-                 str = NULL ;
-         }
-@@ -2685,7 +2685,7 @@ cr_statement_dump_page (CRStatement * a_this, FILE * a_fp, gulong a_indent)
- 
-         str = cr_statement_at_page_rule_to_string (a_this, a_indent) ;
-         if (str) {
--                fprintf (a_fp, str);
-+                fprintf (a_fp, "%s", str);
-                 g_free (str) ;
-                 str = NULL ; 
-         }
-@@ -2711,7 +2711,7 @@ cr_statement_dump_media_rule (CRStatement * a_this,
- 
-         str = cr_statement_media_rule_to_string (a_this, a_indent) ;
-         if (str) {
--                fprintf (a_fp, str) ;
-+                fprintf (a_fp, "%s", str) ;
-                 g_free (str) ;
-                 str = NULL ;
-         }
-@@ -2737,7 +2737,7 @@ cr_statement_dump_import_rule (CRStatement * a_this, FILE * a_fp,
- 
-         str = cr_statement_import_rule_to_string (a_this, a_indent) ;
-         if (str) {
--                fprintf (a_fp, str) ;
-+                fprintf (a_fp, "%s", str) ;
-                 g_free (str) ;
-                 str = NULL ;
-         }
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/0001-init-env.in-do-not-add-C-CXX-parameters.patch b/poky/meta/recipes-core/gettext/gettext-0.20.2/0001-init-env.in-do-not-add-C-CXX-parameters.patch
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/0001-init-env.in-do-not-add-C-CXX-parameters.patch
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/0001-init-env.in-do-not-add-C-CXX-parameters.patch
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/0001-tests-autopoint-3-unset-MAKEFLAGS.patch b/poky/meta/recipes-core/gettext/gettext-0.20.2/0001-tests-autopoint-3-unset-MAKEFLAGS.patch
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/0001-tests-autopoint-3-unset-MAKEFLAGS.patch
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/0001-tests-autopoint-3-unset-MAKEFLAGS.patch
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/add-with-bisonlocaledir.patch b/poky/meta/recipes-core/gettext/gettext-0.20.2/add-with-bisonlocaledir.patch
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/add-with-bisonlocaledir.patch
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/add-with-bisonlocaledir.patch
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/parallel.patch b/poky/meta/recipes-core/gettext/gettext-0.20.2/parallel.patch
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/parallel.patch
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/parallel.patch
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/run-ptest b/poky/meta/recipes-core/gettext/gettext-0.20.2/run-ptest
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/run-ptest
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/run-ptest
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/serial-tests-config.patch b/poky/meta/recipes-core/gettext/gettext-0.20.2/serial-tests-config.patch
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/serial-tests-config.patch
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/serial-tests-config.patch
diff --git a/poky/meta/recipes-core/gettext/gettext-0.20.1/use-pkgconfig.patch b/poky/meta/recipes-core/gettext/gettext-0.20.2/use-pkgconfig.patch
similarity index 95%
rename from poky/meta/recipes-core/gettext/gettext-0.20.1/use-pkgconfig.patch
rename to poky/meta/recipes-core/gettext/gettext-0.20.2/use-pkgconfig.patch
index d3f3fe8..feb5671 100644
--- a/poky/meta/recipes-core/gettext/gettext-0.20.1/use-pkgconfig.patch
+++ b/poky/meta/recipes-core/gettext/gettext-0.20.2/use-pkgconfig.patch
@@ -1,4 +1,4 @@
-From ef414b06be80c6f605731abc9e674e396b80ec9e Mon Sep 17 00:00:00 2001
+From c832880c5242b454a2c9e61b6a2dc26aecdc51bd Mon Sep 17 00:00:00 2001
 From: Ross Burton <ross.burton@intel.com>
 Date: Tue, 23 Jan 2018 00:54:13 +0000
 Subject: [PATCH] gettext: beat library detection into shape
@@ -15,14 +15,14 @@
 
 ---
  gettext-tools/gnulib-m4/libxml.m4             |  99 +----------------
- .../gnulib-local/lib/term-styled-ostream.oo.c |  12 +-
+ .../gnulib-local/lib/term-styled-ostream.oo.c |  12 +--
  libtextstyle/gnulib-local/m4/libcroco.m4      |  99 +++--------------
- libtextstyle/gnulib-local/m4/libglib.m4       | 104 +++---------------
+ libtextstyle/gnulib-local/m4/libglib.m4       | 100 +++---------------
  libtextstyle/gnulib-m4/libcroco.m4            |  99 +++--------------
- libtextstyle/gnulib-m4/libglib.m4             | 104 +++---------------
- libtextstyle/lib/term-styled-ostream.c        |  12 +-
- libtextstyle/lib/term-styled-ostream.oo.c     |  12 +-
- 8 files changed, 87 insertions(+), 454 deletions(-)
+ libtextstyle/gnulib-m4/libglib.m4             | 100 +++---------------
+ libtextstyle/lib/term-styled-ostream.c        |  12 +--
+ libtextstyle/lib/term-styled-ostream.oo.c     |  12 +--
+ 8 files changed, 83 insertions(+), 450 deletions(-)
 
 diff --git a/gettext-tools/gnulib-m4/libxml.m4 b/gettext-tools/gnulib-m4/libxml.m4
 index 05b9550..031ee65 100644
@@ -289,17 +289,10 @@
    AC_SUBST([LTLIBCROCO])
    AC_SUBST([INCCROCO])
 diff --git a/libtextstyle/gnulib-local/m4/libglib.m4 b/libtextstyle/gnulib-local/m4/libglib.m4
-index bef6fa3..8841755 100644
+index 5853772..767fba2 100644
 --- a/libtextstyle/gnulib-local/m4/libglib.m4
 +++ b/libtextstyle/gnulib-local/m4/libglib.m4
-@@ -1,105 +1,31 @@
--# libglib.m4 serial 4
--dnl Copyright (C) 2006-2007, 2019 Free Software Foundation, Inc.
-+# libglib.m4 serial 3 (gettext-0.17)
-+dnl Copyright (C) 2006-2007, 2015-2016 Free Software Foundation, Inc.
- dnl This file is free software; the Free Software Foundation
- dnl gives unlimited permission to copy and/or distribute it,
- dnl with or without modifications, as long as this notice is preserved.
+@@ -6,100 +6,26 @@ dnl with or without modifications, as long as this notice is preserved.
  
  dnl From Bruno Haible.
  
@@ -535,17 +528,10 @@
    AC_SUBST([LTLIBCROCO])
    AC_SUBST([INCCROCO])
 diff --git a/libtextstyle/gnulib-m4/libglib.m4 b/libtextstyle/gnulib-m4/libglib.m4
-index bef6fa3..8841755 100644
+index 5853772..767fba2 100644
 --- a/libtextstyle/gnulib-m4/libglib.m4
 +++ b/libtextstyle/gnulib-m4/libglib.m4
-@@ -1,105 +1,31 @@
--# libglib.m4 serial 4
--dnl Copyright (C) 2006-2007, 2019 Free Software Foundation, Inc.
-+# libglib.m4 serial 3 (gettext-0.17)
-+dnl Copyright (C) 2006-2007, 2015-2016 Free Software Foundation, Inc.
- dnl This file is free software; the Free Software Foundation
- dnl gives unlimited permission to copy and/or distribute it,
- dnl with or without modifications, as long as this notice is preserved.
+@@ -6,100 +6,26 @@ dnl with or without modifications, as long as this notice is preserved.
  
  dnl From Bruno Haible.
  
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-prefix.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-prefix.m4
deleted file mode 100644
index 8adb17b..0000000
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-prefix.m4
+++ /dev/null
@@ -1,249 +0,0 @@
-# lib-prefix.m4 serial 14
-dnl Copyright (C) 2001-2005, 2008-2019 Free Software Foundation, Inc.
-dnl This file is free software; the Free Software Foundation
-dnl gives unlimited permission to copy and/or distribute it,
-dnl with or without modifications, as long as this notice is preserved.
-
-dnl From Bruno Haible.
-
-dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
-dnl to access previously installed libraries. The basic assumption is that
-dnl a user will want packages to use other packages he previously installed
-dnl with the same --prefix option.
-dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
-dnl libraries, but is otherwise very convenient.
-AC_DEFUN([AC_LIB_PREFIX],
-[
-  AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
-  AC_REQUIRE([AC_PROG_CC])
-  AC_REQUIRE([AC_CANONICAL_HOST])
-  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
-  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
-  dnl By default, look in $includedir and $libdir.
-  use_additional=yes
-  AC_LIB_WITH_FINAL_PREFIX([
-    eval additional_includedir=\"$includedir\"
-    eval additional_libdir=\"$libdir\"
-  ])
-  AC_ARG_WITH([lib-prefix],
-[[  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
-  --without-lib-prefix    don't search for libraries in includedir and libdir]],
-[
-    if test "X$withval" = "Xno"; then
-      use_additional=no
-    else
-      if test "X$withval" = "X"; then
-        AC_LIB_WITH_FINAL_PREFIX([
-          eval additional_includedir=\"$includedir\"
-          eval additional_libdir=\"$libdir\"
-        ])
-      else
-        additional_includedir="$withval/include"
-        additional_libdir="$withval/$acl_libdirstem"
-      fi
-    fi
-])
-  if test $use_additional = yes; then
-    dnl Potentially add $additional_includedir to $CPPFLAGS.
-    dnl But don't add it
-    dnl   1. if it's the standard /usr/include,
-    dnl   2. if it's already present in $CPPFLAGS,
-    dnl   3. if it's /usr/local/include and we are using GCC on Linux,
-    dnl   4. if it doesn't exist as a directory.
-    if test "X$additional_includedir" != "X/usr/include"; then
-      haveit=
-      for x in $CPPFLAGS; do
-        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-        if test "X$x" = "X-I$additional_includedir"; then
-          haveit=yes
-          break
-        fi
-      done
-      if test -z "$haveit"; then
-        if test "X$additional_includedir" = "X/usr/local/include"; then
-          if test -n "$GCC"; then
-            case $host_os in
-              linux* | gnu* | k*bsd*-gnu) haveit=yes;;
-            esac
-          fi
-        fi
-        if test -z "$haveit"; then
-          if test -d "$additional_includedir"; then
-            dnl Really add $additional_includedir to $CPPFLAGS.
-            CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
-          fi
-        fi
-      fi
-    fi
-    dnl Potentially add $additional_libdir to $LDFLAGS.
-    dnl But don't add it
-    dnl   1. if it's the standard /usr/lib,
-    dnl   2. if it's already present in $LDFLAGS,
-    dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
-    dnl   4. if it doesn't exist as a directory.
-    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
-      haveit=
-      for x in $LDFLAGS; do
-        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-        if test "X$x" = "X-L$additional_libdir"; then
-          haveit=yes
-          break
-        fi
-      done
-      if test -z "$haveit"; then
-        if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
-          if test -n "$GCC"; then
-            case $host_os in
-              linux*) haveit=yes;;
-            esac
-          fi
-        fi
-        if test -z "$haveit"; then
-          if test -d "$additional_libdir"; then
-            dnl Really add $additional_libdir to $LDFLAGS.
-            LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
-          fi
-        fi
-      fi
-    fi
-  fi
-])
-
-dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
-dnl acl_final_exec_prefix, containing the values to which $prefix and
-dnl $exec_prefix will expand at the end of the configure script.
-AC_DEFUN([AC_LIB_PREPARE_PREFIX],
-[
-  dnl Unfortunately, prefix and exec_prefix get only finally determined
-  dnl at the end of configure.
-  if test "X$prefix" = "XNONE"; then
-    acl_final_prefix="$ac_default_prefix"
-  else
-    acl_final_prefix="$prefix"
-  fi
-  if test "X$exec_prefix" = "XNONE"; then
-    acl_final_exec_prefix='${prefix}'
-  else
-    acl_final_exec_prefix="$exec_prefix"
-  fi
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
-  prefix="$acl_save_prefix"
-])
-
-dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
-dnl variables prefix and exec_prefix bound to the values they will have
-dnl at the end of the configure script.
-AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
-[
-  acl_save_prefix="$prefix"
-  prefix="$acl_final_prefix"
-  acl_save_exec_prefix="$exec_prefix"
-  exec_prefix="$acl_final_exec_prefix"
-  $1
-  exec_prefix="$acl_save_exec_prefix"
-  prefix="$acl_save_prefix"
-])
-
-dnl AC_LIB_PREPARE_MULTILIB creates
-dnl - a variable acl_libdirstem, containing the basename of the libdir, either
-dnl   "lib" or "lib64" or "lib/64",
-dnl - a variable acl_libdirstem2, as a secondary possible value for
-dnl   acl_libdirstem, either the same as acl_libdirstem or "lib/sparcv9" or
-dnl   "lib/amd64".
-AC_DEFUN([AC_LIB_PREPARE_MULTILIB],
-[
-  dnl There is no formal standard regarding lib and lib64.
-  dnl On glibc systems, the current practice is that on a system supporting
-  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
-  dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. We determine
-  dnl the compiler's default mode by looking at the compiler's library search
-  dnl path. If at least one of its elements ends in /lib64 or points to a
-  dnl directory whose absolute pathname ends in /lib64, we assume a 64-bit ABI.
-  dnl Otherwise we use the default, namely "lib".
-  dnl On Solaris systems, the current practice is that on a system supporting
-  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
-  dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or
-  dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib.
-  AC_REQUIRE([AC_CANONICAL_HOST])
-  AC_REQUIRE([gl_HOST_CPU_C_ABI_32BIT])
-
-  case "$host_os" in
-    solaris*)
-      AC_CACHE_CHECK([for 64-bit host], [gl_cv_solaris_64bit],
-        [AC_COMPILE_IFELSE(
-           [AC_LANG_SOURCE(
-              [[#ifdef _LP64
-                 int ok;
-                #else
-                 error fail
-                #endif
-              ]])],
-           [gl_cv_solaris_64bit=yes],
-           [gl_cv_solaris_64bit=no])
-        ]);;
-  esac
-
-  dnl Allow the user to override the result by setting acl_cv_libdirstems.
-  AC_CACHE_CHECK([for the common suffixes of directories in the library search path],
-    [acl_cv_libdirstems],
-    [acl_libdirstem=lib
-     acl_libdirstem2=
-     case "$host_os" in
-       solaris*)
-         dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment
-         dnl <https://docs.oracle.com/cd/E19253-01/816-5138/dev-env/index.html>.
-         dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link."
-         dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the
-         dnl symlink is missing, so we set acl_libdirstem2 too.
-         if test $gl_cv_solaris_64bit = yes; then
-           acl_libdirstem=lib/64
-           case "$host_cpu" in
-             sparc*)        acl_libdirstem2=lib/sparcv9 ;;
-             i*86 | x86_64) acl_libdirstem2=lib/amd64 ;;
-           esac
-         fi
-         ;;
-       *)
-         dnl If $CC generates code for a 32-bit ABI, the libraries are
-         dnl surely under $prefix/lib, not $prefix/lib64.
-         if test "$HOST_CPU_C_ABI_32BIT" != yes; then
-           dnl The result is a property of the system. However, non-system
-           dnl compilers sometimes have odd library search paths. Therefore
-           dnl prefer asking /usr/bin/gcc, if available, rather than $CC.
-           searchpath=`(if test -f /usr/bin/gcc \
-                           && LC_ALL=C /usr/bin/gcc -print-search-dirs >/dev/null 2>/dev/null; then \
-                          LC_ALL=C /usr/bin/gcc -print-search-dirs; \
-                        else \
-                          LC_ALL=C $CC -print-search-dirs; \
-                        fi) 2>/dev/null \
-                       | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
-           if test -n "$searchpath"; then
-             acl_save_IFS="${IFS= 	}"; IFS=":"
-             for searchdir in $searchpath; do
-               if test -d "$searchdir"; then
-                 case "$searchdir" in
-                   */lib64/ | */lib64 ) acl_libdirstem=lib64 ;;
-                   */../ | */.. )
-                     # Better ignore directories of this form. They are misleading.
-                     ;;
-                   *) searchdir=`cd "$searchdir" && pwd`
-                      case "$searchdir" in
-                        */lib64 ) acl_libdirstem=lib64 ;;
-                      esac ;;
-                 esac
-               fi
-             done
-             IFS="$acl_save_IFS"
-           fi
-         fi
-         ;;
-     esac
-     test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem"
-     acl_cv_libdirstems="$acl_libdirstem,$acl_libdirstem2"
-    ])
-  # Decompose acl_cv_libdirstems into acl_libdirstem and acl_libdirstem2.
-  acl_libdirstem=`echo "$acl_cv_libdirstems" | sed -e 's/,.*//'`
-  acl_libdirstem2=`echo "$acl_cv_libdirstems" | sed -e '/,/s/.*,//'`
-])
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/COPYING b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/COPYING
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/COPYING
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/COPYING
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/Makefile.in.in b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/Makefile.in.in
similarity index 99%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/Makefile.in.in
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/Makefile.in.in
index fdb6ad3..de980e0 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/Makefile.in.in
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/Makefile.in.in
@@ -1,13 +1,13 @@
 # Makefile for PO directory in any package using GNU gettext.
 # Copyright (C) 1995-2000 Ulrich Drepper <drepper@gnu.ai.mit.edu>
-# Copyright (C) 2000-2019 Free Software Foundation, Inc.
+# Copyright (C) 2000-2020 Free Software Foundation, Inc.
 #
 # Copying and distribution of this file, with or without modification,
 # are permitted in any medium without royalty provided the copyright
 # notice and this notice are preserved.  This file is offered as-is,
 # without any warranty.
 #
-# Origin: gettext-0.20
+# Origin: gettext-0.20.2
 GETTEXT_MACRO_VERSION = 0.20
 
 PACKAGE = @PACKAGE@
@@ -90,6 +90,9 @@
 
 # Makevars gets inserted here. (Don't remove this line!)
 
+all: all-@USE_NLS@
+
+
 .SUFFIXES:
 .SUFFIXES: .po .gmo .sed .sin .nop .po-create .po-update
 
@@ -107,7 +110,8 @@
 # the .pot file. This eliminates the need to update the .po files when the
 # .pot file has changed, which would be troublesome if the .po files are put
 # under version control.
-.po.gmo: $(srcdir)/$(DOMAIN).pot
+$(GMOFILES): $(srcdir)/$(DOMAIN).pot
+.po.gmo:
 	@lang=`echo $* | sed -e 's,.*/,,'`; \
 	test "$(srcdir)" = . && cdcmd="" || cdcmd="cd $(srcdir) && "; \
 	echo "$${cdcmd}rm -f $${lang}.gmo && $(MSGMERGE) $(MSGMERGE_FOR_MSGFMT_OPTION) -o $${lang}.1po $${lang}.po $(DOMAIN).pot && $(GMSGFMT) -c --statistics --verbose -o $${lang}.gmo $${lang}.1po && rm -f $${lang}.1po"; \
@@ -123,8 +127,6 @@
 	mv t-$@ $@
 
 
-all: all-@USE_NLS@
-
 all-yes: $(srcdir)/stamp-po
 all-no:
 
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/gettext.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/gettext.m4
similarity index 97%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/gettext.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/gettext.m4
index e783241..4f25a27 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/gettext.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/gettext.m4
@@ -1,15 +1,15 @@
-# gettext.m4 serial 70 (gettext-0.20)
-dnl Copyright (C) 1995-2014, 2016, 2018 Free Software Foundation, Inc.
+# gettext.m4 serial 71 (gettext-0.20.2)
+dnl Copyright (C) 1995-2014, 2016, 2018-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 dnl
 dnl This file can be used in projects which are not available under
-dnl the GNU General Public License or the GNU Library General Public
+dnl the GNU General Public License or the GNU Lesser General Public
 dnl License but which still want to provide support for the GNU gettext
 dnl functionality.
 dnl Please note that the actual code of the GNU gettext library is covered
-dnl by the GNU Library General Public License, and the rest of the GNU
+dnl by the GNU Lesser General Public License, and the rest of the GNU
 dnl gettext package is covered by the GNU General Public License.
 dnl They are *not* in the public domain.
 
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/host-cpu-c-abi.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/host-cpu-c-abi.m4
similarity index 94%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/host-cpu-c-abi.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/host-cpu-c-abi.m4
index 4407296..6db2aa2 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/host-cpu-c-abi.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/host-cpu-c-abi.m4
@@ -1,5 +1,5 @@
-# host-cpu-c-abi.m4 serial 11
-dnl Copyright (C) 2002-2019 Free Software Foundation, Inc.
+# host-cpu-c-abi.m4 serial 13
+dnl Copyright (C) 2002-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
@@ -55,7 +55,7 @@
     [case "$host_cpu" in
 
 changequote(,)dnl
-       i[4567]86 )
+       i[34567]86 )
 changequote([,])dnl
          gl_cv_host_cpu_c_abi=i386
          ;;
@@ -457,7 +457,8 @@
 
 
 dnl Sets the HOST_CPU_C_ABI_32BIT variable to 'yes' if the C language ABI
-dnl (application binary interface) is a 32-bit one, or to 'no' otherwise.
+dnl (application binary interface) is a 32-bit one, to 'no' if it is a 64-bit
+dnl one, or to 'unknown' if unknown.
 dnl This is a simplified variant of gl_HOST_CPU_C_ABI.
 AC_DEFUN([gl_HOST_CPU_C_ABI_32BIT],
 [
@@ -467,14 +468,44 @@
        case "$gl_cv_host_cpu_c_abi" in
          i386 | x86_64-x32 | arm | armhf | arm64-ilp32 | hppa | ia64-ilp32 | mips | mipsn32 | powerpc | riscv*-ilp32* | s390 | sparc)
            gl_cv_host_cpu_c_abi_32bit=yes ;;
-         *)
+         x86_64 | alpha | arm64 | hppa64 | ia64 | mips64 | powerpc64 | powerpc64-elfv2 | riscv*-lp64* | s390x | sparc64 )
            gl_cv_host_cpu_c_abi_32bit=no ;;
+         *)
+           gl_cv_host_cpu_c_abi_32bit=unknown ;;
        esac
      else
        case "$host_cpu" in
 
+         # CPUs that only support a 32-bit ABI.
+         arc \
+         | bfin \
+         | cris* \
+         | csky \
+         | epiphany \
+         | ft32 \
+         | h8300 \
+         | m68k \
+         | microblaze | microblazeel \
+         | nds32 | nds32le | nds32be \
+         | nios2 | nios2eb | nios2el \
+         | or1k* \
+         | or32 \
+         | sh | sh[1234] | sh[1234]e[lb] \
+         | tic6x \
+         | xtensa* )
+           gl_cv_host_cpu_c_abi_32bit=yes
+           ;;
+
+         # CPUs that only support a 64-bit ABI.
 changequote(,)dnl
-         i[4567]86 )
+         alpha | alphaev[4-8] | alphaev56 | alphapca5[67] | alphaev6[78] \
+         | mmix )
+changequote([,])dnl
+           gl_cv_host_cpu_c_abi_32bit=no
+           ;;
+
+changequote(,)dnl
+         i[34567]86 )
 changequote([,])dnl
            gl_cv_host_cpu_c_abi_32bit=yes
            ;;
@@ -634,7 +665,7 @@
            ;;
 
          *)
-           gl_cv_host_cpu_c_abi_32bit=no
+           gl_cv_host_cpu_c_abi_32bit=unknown
            ;;
        esac
      fi
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/iconv.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/iconv.m4
similarity index 99%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/iconv.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/iconv.m4
index a285e9d..e593b72 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/iconv.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/iconv.m4
@@ -1,5 +1,5 @@
 # iconv.m4 serial 21
-dnl Copyright (C) 2000-2002, 2007-2014, 2016-2019 Free Software Foundation,
+dnl Copyright (C) 2000-2002, 2007-2014, 2016-2020 Free Software Foundation,
 dnl Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/intlmacosx.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/intlmacosx.m4
similarity index 70%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/intlmacosx.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/intlmacosx.m4
index 30e6f50e..ebd9937 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/intlmacosx.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/intlmacosx.m4
@@ -1,15 +1,15 @@
-# intlmacosx.m4 serial 6 (gettext-0.20)
-dnl Copyright (C) 2004-2014, 2016, 2019 Free Software Foundation, Inc.
+# intlmacosx.m4 serial 8 (gettext-0.20.2)
+dnl Copyright (C) 2004-2014, 2016, 2019-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 dnl
 dnl This file can be used in projects which are not available under
-dnl the GNU General Public License or the GNU Library General Public
+dnl the GNU General Public License or the GNU Lesser General Public
 dnl License but which still want to provide support for the GNU gettext
 dnl functionality.
 dnl Please note that the actual code of the GNU gettext library is covered
-dnl by the GNU Library General Public License, and the rest of the GNU
+dnl by the GNU Lesser General Public License, and the rest of the GNU
 dnl gettext package is covered by the GNU General Public License.
 dnl They are *not* in the public domain.
 
@@ -33,21 +33,15 @@
     AC_DEFINE([HAVE_CFPREFERENCESCOPYAPPVALUE], [1],
       [Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in the CoreFoundation framework.])
   fi
-  dnl Check for API introduced in Mac OS X 10.5.
-  AC_CACHE_CHECK([for CFLocaleCopyCurrent], [gt_cv_func_CFLocaleCopyCurrent],
-    [gt_save_LIBS="$LIBS"
-     LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation"
-     AC_LINK_IFELSE(
-       [AC_LANG_PROGRAM(
-          [[#include <CoreFoundation/CFLocale.h>]],
-          [[CFLocaleCopyCurrent();]])],
-       [gt_cv_func_CFLocaleCopyCurrent=yes],
-       [gt_cv_func_CFLocaleCopyCurrent=no])
-     LIBS="$gt_save_LIBS"])
-  if test $gt_cv_func_CFLocaleCopyCurrent = yes; then
-    AC_DEFINE([HAVE_CFLOCALECOPYCURRENT], [1],
-      [Define to 1 if you have the Mac OS X function CFLocaleCopyCurrent in the CoreFoundation framework.])
-  fi
+  dnl Don't check for the API introduced in Mac OS X 10.5, CFLocaleCopyCurrent,
+  dnl because in macOS 10.13.4 it has the following behaviour:
+  dnl When two or more languages are specified in the
+  dnl "System Preferences > Language & Region > Preferred Languages" panel,
+  dnl it returns en_CC where CC is the territory (even when English is not among
+  dnl the preferred languages!).  What we want instead is what
+  dnl CFLocaleCopyCurrent returned in earlier macOS releases and what
+  dnl CFPreferencesCopyAppValue still returns, namely ll_CC where ll is the
+  dnl first among the preferred languages and CC is the territory.
   AC_CACHE_CHECK([for CFLocaleCopyPreferredLanguages], [gt_cv_func_CFLocaleCopyPreferredLanguages],
     [gt_save_LIBS="$LIBS"
      LIBS="$LIBS -Wl,-framework -Wl,CoreFoundation"
@@ -64,7 +58,6 @@
   fi
   INTL_MACOSX_LIBS=
   if test $gt_cv_func_CFPreferencesCopyAppValue = yes \
-     || test $gt_cv_func_CFLocaleCopyCurrent = yes \
      || test $gt_cv_func_CFLocaleCopyPreferredLanguages = yes; then
     INTL_MACOSX_LIBS="-Wl,-framework -Wl,CoreFoundation"
   fi
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-ld.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-ld.m4
similarity index 98%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-ld.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-ld.m4
index a187196..98c348f 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-ld.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-ld.m4
@@ -1,5 +1,5 @@
 # lib-ld.m4 serial 9
-dnl Copyright (C) 1996-2003, 2009-2019 Free Software Foundation, Inc.
+dnl Copyright (C) 1996-2003, 2009-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-link.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-link.m4
similarity index 85%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-link.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-link.m4
index 0ff1073..eecf70e 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/lib-link.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-link.m4
@@ -1,5 +1,5 @@
-# lib-link.m4 serial 28
-dnl Copyright (C) 2001-2019 Free Software Foundation, Inc.
+# lib-link.m4 serial 31
+dnl Copyright (C) 2001-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
@@ -192,6 +192,8 @@
   AC_LIB_WITH_FINAL_PREFIX([
     eval additional_includedir=\"$includedir\"
     eval additional_libdir=\"$libdir\"
+    eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\"
+    eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\"
   ])
   AC_ARG_WITH(PACK[-prefix],
 [[  --with-]]PACK[[-prefix[=DIR]  search for ]PACKLIBS[ in DIR/include and DIR/lib
@@ -204,17 +206,23 @@
         AC_LIB_WITH_FINAL_PREFIX([
           eval additional_includedir=\"$includedir\"
           eval additional_libdir=\"$libdir\"
+          eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\"
+          eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\"
         ])
       else
         additional_includedir="$withval/include"
         additional_libdir="$withval/$acl_libdirstem"
-        if test "$acl_libdirstem2" != "$acl_libdirstem" \
-           && test ! -d "$withval/$acl_libdirstem"; then
-          additional_libdir="$withval/$acl_libdirstem2"
-        fi
+        additional_libdir2="$withval/$acl_libdirstem2"
+        additional_libdir3="$withval/$acl_libdirstem3"
       fi
     fi
 ])
+  if test "X$additional_libdir2" = "X$additional_libdir"; then
+    additional_libdir2=
+  fi
+  if test "X$additional_libdir3" = "X$additional_libdir"; then
+    additional_libdir3=
+  fi
   dnl Search the library and its dependencies in $additional_libdir and
   dnl $LDFLAGS. Using breadth-first-seach.
   LIB[]NAME=
@@ -270,58 +278,14 @@
             shrext=
           fi
           if test $use_additional = yes; then
-            dir="$additional_libdir"
-            dnl The same code as in the loop below:
-            dnl First look for a shared library.
-            if test -n "$acl_shlibext"; then
-              if test -f "$dir/$libname$shrext"; then
-                found_dir="$dir"
-                found_so="$dir/$libname$shrext"
-              else
-                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
-                  ver=`(cd "$dir" && \
-                        for f in "$libname$shrext".*; do echo "$f"; done \
-                        | sed -e "s,^$libname$shrext\\\\.,," \
-                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
-                        | sed 1q ) 2>/dev/null`
-                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
-                    found_dir="$dir"
-                    found_so="$dir/$libname$shrext.$ver"
-                  fi
-                else
-                  eval library_names=\"$acl_library_names_spec\"
-                  for f in $library_names; do
-                    if test -f "$dir/$f"; then
-                      found_dir="$dir"
-                      found_so="$dir/$f"
-                      break
-                    fi
-                  done
-                fi
-              fi
-            fi
-            dnl Then look for a static library.
-            if test "X$found_dir" = "X"; then
-              if test -f "$dir/$libname.$acl_libext"; then
-                found_dir="$dir"
-                found_a="$dir/$libname.$acl_libext"
-              fi
-            fi
-            if test "X$found_dir" != "X"; then
-              if test -f "$dir/$libname.la"; then
-                found_la="$dir/$libname.la"
-              fi
-            fi
-          fi
-          if test "X$found_dir" = "X"; then
-            for x in $LDFLAGS $LTLIB[]NAME; do
-              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-              case "$x" in
-                -L*)
-                  dir=`echo "X$x" | sed -e 's/^X-L//'`
+            for additional_libdir_variable in additional_libdir additional_libdir2 additional_libdir3; do
+              if test "X$found_dir" = "X"; then
+                eval dir=\$$additional_libdir_variable
+                if test -n "$dir"; then
+                  dnl The same code as in the loop below:
                   dnl First look for a shared library.
                   if test -n "$acl_shlibext"; then
-                    if test -f "$dir/$libname$shrext"; then
+                    if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then
                       found_dir="$dir"
                       found_so="$dir/$libname$shrext"
                     else
@@ -331,14 +295,14 @@
                               | sed -e "s,^$libname$shrext\\\\.,," \
                               | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
                               | sed 1q ) 2>/dev/null`
-                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
+                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then
                           found_dir="$dir"
                           found_so="$dir/$libname$shrext.$ver"
                         fi
                       else
                         eval library_names=\"$acl_library_names_spec\"
                         for f in $library_names; do
-                          if test -f "$dir/$f"; then
+                          if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then
                             found_dir="$dir"
                             found_so="$dir/$f"
                             break
@@ -349,7 +313,57 @@
                   fi
                   dnl Then look for a static library.
                   if test "X$found_dir" = "X"; then
-                    if test -f "$dir/$libname.$acl_libext"; then
+                    if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then
+                      found_dir="$dir"
+                      found_a="$dir/$libname.$acl_libext"
+                    fi
+                  fi
+                  if test "X$found_dir" != "X"; then
+                    if test -f "$dir/$libname.la"; then
+                      found_la="$dir/$libname.la"
+                    fi
+                  fi
+                fi
+              fi
+            done
+          fi
+          if test "X$found_dir" = "X"; then
+            for x in $LDFLAGS $LTLIB[]NAME; do
+              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
+              case "$x" in
+                -L*)
+                  dir=`echo "X$x" | sed -e 's/^X-L//'`
+                  dnl First look for a shared library.
+                  if test -n "$acl_shlibext"; then
+                    if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then
+                      found_dir="$dir"
+                      found_so="$dir/$libname$shrext"
+                    else
+                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
+                        ver=`(cd "$dir" && \
+                              for f in "$libname$shrext".*; do echo "$f"; done \
+                              | sed -e "s,^$libname$shrext\\\\.,," \
+                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
+                              | sed 1q ) 2>/dev/null`
+                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then
+                          found_dir="$dir"
+                          found_so="$dir/$libname$shrext.$ver"
+                        fi
+                      else
+                        eval library_names=\"$acl_library_names_spec\"
+                        for f in $library_names; do
+                          if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then
+                            found_dir="$dir"
+                            found_so="$dir/$f"
+                            break
+                          fi
+                        done
+                      fi
+                    fi
+                  fi
+                  dnl Then look for a static library.
+                  if test "X$found_dir" = "X"; then
+                    if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then
                       found_dir="$dir"
                       found_a="$dir/$libname.$acl_libext"
                     fi
@@ -375,7 +389,8 @@
               dnl standard /usr/lib.
               if test "$enable_rpath" = no \
                  || test "X$found_dir" = "X/usr/$acl_libdirstem" \
-                 || test "X$found_dir" = "X/usr/$acl_libdirstem2"; then
+                 || test "X$found_dir" = "X/usr/$acl_libdirstem2" \
+                 || test "X$found_dir" = "X/usr/$acl_libdirstem3"; then
                 dnl No hardcoding is needed.
                 LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
               else
@@ -475,6 +490,13 @@
                 fi
                 additional_includedir="$basedir/include"
                 ;;
+              */$acl_libdirstem3 | */$acl_libdirstem3/)
+                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem3/"'*$,,'`
+                if test "$name" = '$1'; then
+                  LIB[]NAME[]_PREFIX="$basedir"
+                fi
+                additional_includedir="$basedir/include"
+                ;;
             esac
             if test "X$additional_includedir" != "X"; then
               dnl Potentially add $additional_includedir to $INCNAME.
@@ -525,19 +547,21 @@
               for dep in $dependency_libs; do
                 case "$dep" in
                   -L*)
-                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
-                    dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
+                    dependency_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
+                    dnl Potentially add $dependency_libdir to $LIBNAME and $LTLIBNAME.
                     dnl But don't add it
                     dnl   1. if it's the standard /usr/lib,
                     dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
                     dnl   3. if it's already present in $LDFLAGS or the already
                     dnl      constructed $LIBNAME,
                     dnl   4. if it doesn't exist as a directory.
-                    if test "X$additional_libdir" != "X/usr/$acl_libdirstem" \
-                       && test "X$additional_libdir" != "X/usr/$acl_libdirstem2"; then
+                    if test "X$dependency_libdir" != "X/usr/$acl_libdirstem" \
+                       && test "X$dependency_libdir" != "X/usr/$acl_libdirstem2" \
+                       && test "X$dependency_libdir" != "X/usr/$acl_libdirstem3"; then
                       haveit=
-                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem" \
-                         || test "X$additional_libdir" = "X/usr/local/$acl_libdirstem2"; then
+                      if test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem" \
+                         || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem2" \
+                         || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem3"; then
                         if test -n "$GCC"; then
                           case $host_os in
                             linux* | gnu* | k*bsd*-gnu) haveit=yes;;
@@ -548,29 +572,29 @@
                         haveit=
                         for x in $LDFLAGS $LIB[]NAME; do
                           AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-                          if test "X$x" = "X-L$additional_libdir"; then
+                          if test "X$x" = "X-L$dependency_libdir"; then
                             haveit=yes
                             break
                           fi
                         done
                         if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                            dnl Really add $additional_libdir to $LIBNAME.
-                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
+                          if test -d "$dependency_libdir"; then
+                            dnl Really add $dependency_libdir to $LIBNAME.
+                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$dependency_libdir"
                           fi
                         fi
                         haveit=
                         for x in $LDFLAGS $LTLIB[]NAME; do
                           AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
-                          if test "X$x" = "X-L$additional_libdir"; then
+                          if test "X$x" = "X-L$dependency_libdir"; then
                             haveit=yes
                             break
                           fi
                         done
                         if test -z "$haveit"; then
-                          if test -d "$additional_libdir"; then
-                            dnl Really add $additional_libdir to $LTLIBNAME.
-                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
+                          if test -d "$dependency_libdir"; then
+                            dnl Really add $dependency_libdir to $LTLIBNAME.
+                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$dependency_libdir"
                           fi
                         fi
                       fi
@@ -718,7 +742,8 @@
           dir="$next"
           dnl No need to hardcode the standard /usr/lib.
           if test "X$dir" != "X/usr/$acl_libdirstem" \
-             && test "X$dir" != "X/usr/$acl_libdirstem2"; then
+             && test "X$dir" != "X/usr/$acl_libdirstem2" \
+             && test "X$dir" != "X/usr/$acl_libdirstem3"; then
             rpathdirs="$rpathdirs $dir"
           fi
           next=
@@ -728,7 +753,8 @@
             -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
                  dnl No need to hardcode the standard /usr/lib.
                  if test "X$dir" != "X/usr/$acl_libdirstem" \
-                    && test "X$dir" != "X/usr/$acl_libdirstem2"; then
+                    && test "X$dir" != "X/usr/$acl_libdirstem2" \
+                    && test "X$dir" != "X/usr/$acl_libdirstem3"; then
                    rpathdirs="$rpathdirs $dir"
                  fi
                  next= ;;
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-prefix.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-prefix.m4
new file mode 100644
index 0000000..c8a0b46
--- /dev/null
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/lib-prefix.m4
@@ -0,0 +1,320 @@
+# lib-prefix.m4 serial 17
+dnl Copyright (C) 2001-2005, 2008-2020 Free Software Foundation, Inc.
+dnl This file is free software; the Free Software Foundation
+dnl gives unlimited permission to copy and/or distribute it,
+dnl with or without modifications, as long as this notice is preserved.
+
+dnl From Bruno Haible.
+
+dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
+dnl to access previously installed libraries. The basic assumption is that
+dnl a user will want packages to use other packages he previously installed
+dnl with the same --prefix option.
+dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
+dnl libraries, but is otherwise very convenient.
+AC_DEFUN([AC_LIB_PREFIX],
+[
+  AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
+  AC_REQUIRE([AC_PROG_CC])
+  AC_REQUIRE([AC_CANONICAL_HOST])
+  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
+  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
+  dnl By default, look in $includedir and $libdir.
+  use_additional=yes
+  AC_LIB_WITH_FINAL_PREFIX([
+    eval additional_includedir=\"$includedir\"
+    eval additional_libdir=\"$libdir\"
+  ])
+  AC_ARG_WITH([lib-prefix],
+[[  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
+  --without-lib-prefix    don't search for libraries in includedir and libdir]],
+[
+    if test "X$withval" = "Xno"; then
+      use_additional=no
+    else
+      if test "X$withval" = "X"; then
+        AC_LIB_WITH_FINAL_PREFIX([
+          eval additional_includedir=\"$includedir\"
+          eval additional_libdir=\"$libdir\"
+        ])
+      else
+        additional_includedir="$withval/include"
+        additional_libdir="$withval/$acl_libdirstem"
+      fi
+    fi
+])
+  if test $use_additional = yes; then
+    dnl Potentially add $additional_includedir to $CPPFLAGS.
+    dnl But don't add it
+    dnl   1. if it's the standard /usr/include,
+    dnl   2. if it's already present in $CPPFLAGS,
+    dnl   3. if it's /usr/local/include and we are using GCC on Linux,
+    dnl   4. if it doesn't exist as a directory.
+    if test "X$additional_includedir" != "X/usr/include"; then
+      haveit=
+      for x in $CPPFLAGS; do
+        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
+        if test "X$x" = "X-I$additional_includedir"; then
+          haveit=yes
+          break
+        fi
+      done
+      if test -z "$haveit"; then
+        if test "X$additional_includedir" = "X/usr/local/include"; then
+          if test -n "$GCC"; then
+            case $host_os in
+              linux* | gnu* | k*bsd*-gnu) haveit=yes;;
+            esac
+          fi
+        fi
+        if test -z "$haveit"; then
+          if test -d "$additional_includedir"; then
+            dnl Really add $additional_includedir to $CPPFLAGS.
+            CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
+          fi
+        fi
+      fi
+    fi
+    dnl Potentially add $additional_libdir to $LDFLAGS.
+    dnl But don't add it
+    dnl   1. if it's the standard /usr/lib,
+    dnl   2. if it's already present in $LDFLAGS,
+    dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
+    dnl   4. if it doesn't exist as a directory.
+    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
+      haveit=
+      for x in $LDFLAGS; do
+        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
+        if test "X$x" = "X-L$additional_libdir"; then
+          haveit=yes
+          break
+        fi
+      done
+      if test -z "$haveit"; then
+        if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
+          if test -n "$GCC"; then
+            case $host_os in
+              linux*) haveit=yes;;
+            esac
+          fi
+        fi
+        if test -z "$haveit"; then
+          if test -d "$additional_libdir"; then
+            dnl Really add $additional_libdir to $LDFLAGS.
+            LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
+          fi
+        fi
+      fi
+    fi
+  fi
+])
+
+dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
+dnl acl_final_exec_prefix, containing the values to which $prefix and
+dnl $exec_prefix will expand at the end of the configure script.
+AC_DEFUN([AC_LIB_PREPARE_PREFIX],
+[
+  dnl Unfortunately, prefix and exec_prefix get only finally determined
+  dnl at the end of configure.
+  if test "X$prefix" = "XNONE"; then
+    acl_final_prefix="$ac_default_prefix"
+  else
+    acl_final_prefix="$prefix"
+  fi
+  if test "X$exec_prefix" = "XNONE"; then
+    acl_final_exec_prefix='${prefix}'
+  else
+    acl_final_exec_prefix="$exec_prefix"
+  fi
+  acl_save_prefix="$prefix"
+  prefix="$acl_final_prefix"
+  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
+  prefix="$acl_save_prefix"
+])
+
+dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
+dnl variables prefix and exec_prefix bound to the values they will have
+dnl at the end of the configure script.
+AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
+[
+  acl_save_prefix="$prefix"
+  prefix="$acl_final_prefix"
+  acl_save_exec_prefix="$exec_prefix"
+  exec_prefix="$acl_final_exec_prefix"
+  $1
+  exec_prefix="$acl_save_exec_prefix"
+  prefix="$acl_save_prefix"
+])
+
+dnl AC_LIB_PREPARE_MULTILIB creates
+dnl - a function acl_is_expected_elfclass, that tests whether standard input
+dn;   has a 32-bit or 64-bit ELF header, depending on the host CPU ABI,
+dnl - 3 variables acl_libdirstem, acl_libdirstem2, acl_libdirstem3, containing
+dnl   the basename of the libdir to try in turn, either "lib" or "lib64" or
+dnl   "lib/64" or "lib32" or "lib/sparcv9" or "lib/amd64" or similar.
+AC_DEFUN([AC_LIB_PREPARE_MULTILIB],
+[
+  dnl There is no formal standard regarding lib, lib32, and lib64.
+  dnl On most glibc systems, the current practice is that on a system supporting
+  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
+  dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. However, on
+  dnl Arch Linux based distributions, it's the opposite: 32-bit libraries go
+  dnl under $prefix/lib32 and 64-bit libraries go under $prefix/lib.
+  dnl We determine the compiler's default mode by looking at the compiler's
+  dnl library search path. If at least one of its elements ends in /lib64 or
+  dnl points to a directory whose absolute pathname ends in /lib64, we use that
+  dnl for 64-bit ABIs. Similarly for 32-bit ABIs. Otherwise we use the default,
+  dnl namely "lib".
+  dnl On Solaris systems, the current practice is that on a system supporting
+  dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under
+  dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or
+  dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib.
+  AC_REQUIRE([AC_CANONICAL_HOST])
+  AC_REQUIRE([gl_HOST_CPU_C_ABI_32BIT])
+
+  AC_CACHE_CHECK([for ELF binary format], [gl_cv_elf],
+    [AC_EGREP_CPP([Extensible Linking Format],
+       [#ifdef __ELF__
+        Extensible Linking Format
+        #endif
+       ],
+       [gl_cv_elf=yes],
+       [gl_cv_elf=no])
+     ])
+  if test $gl_cv_elf; then
+    # Extract the ELF class of a file (5th byte) in decimal.
+    # Cf. https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header
+    if od -A x < /dev/null >/dev/null 2>/dev/null; then
+      # Use POSIX od.
+      func_elfclass ()
+      {
+        od -A n -t d1 -j 4 -N 1
+      }
+    else
+      # Use BSD hexdump.
+      func_elfclass ()
+      {
+        dd bs=1 count=1 skip=4 2>/dev/null | hexdump -e '1/1 "%3d "'
+        echo
+      }
+    fi
+changequote(,)dnl
+    case $HOST_CPU_C_ABI_32BIT in
+      yes)
+        # 32-bit ABI.
+        acl_is_expected_elfclass ()
+        {
+          test "`func_elfclass | sed -e 's/[ 	]//g'`" = 1
+        }
+        ;;
+      no)
+        # 64-bit ABI.
+        acl_is_expected_elfclass ()
+        {
+          test "`func_elfclass | sed -e 's/[ 	]//g'`" = 2
+        }
+        ;;
+      *)
+        # Unknown.
+        acl_is_expected_elfclass ()
+        {
+          :
+        }
+        ;;
+    esac
+changequote([,])dnl
+  else
+    acl_is_expected_elfclass ()
+    {
+      :
+    }
+  fi
+
+  dnl Allow the user to override the result by setting acl_cv_libdirstems.
+  AC_CACHE_CHECK([for the common suffixes of directories in the library search path],
+    [acl_cv_libdirstems],
+    [dnl Try 'lib' first, because that's the default for libdir in GNU, see
+     dnl <https://www.gnu.org/prep/standards/html_node/Directory-Variables.html>.
+     acl_libdirstem=lib
+     acl_libdirstem2=
+     acl_libdirstem3=
+     case "$host_os" in
+       solaris*)
+         dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment
+         dnl <https://docs.oracle.com/cd/E19253-01/816-5138/dev-env/index.html>.
+         dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link."
+         dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the
+         dnl symlink is missing, so we set acl_libdirstem2 too.
+         if test $HOST_CPU_C_ABI_32BIT = no; then
+           acl_libdirstem2=lib/64
+           case "$host_cpu" in
+             sparc*)        acl_libdirstem3=lib/sparcv9 ;;
+             i*86 | x86_64) acl_libdirstem3=lib/amd64 ;;
+           esac
+         fi
+         ;;
+       *)
+         dnl If $CC generates code for a 32-bit ABI, the libraries are
+         dnl surely under $prefix/lib or $prefix/lib32, not $prefix/lib64.
+         dnl Similarly, if $CC generates code for a 64-bit ABI, the libraries
+         dnl are surely under $prefix/lib or $prefix/lib64, not $prefix/lib32.
+         dnl Find the compiler's search path. However, non-system compilers
+         dnl sometimes have odd library search paths. But we can't simply invoke
+         dnl '/usr/bin/gcc -print-search-dirs' because that would not take into
+         dnl account the -m32/-m31 or -m64 options from the $CC or $CFLAGS.
+         searchpath=`(LC_ALL=C $CC $CPPFLAGS $CFLAGS -print-search-dirs) 2>/dev/null \
+                     | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'`
+         if test $HOST_CPU_C_ABI_32BIT != no; then
+           # 32-bit or unknown ABI.
+           if test -d /usr/lib32; then
+             acl_libdirstem2=lib32
+           fi
+         fi
+         if test $HOST_CPU_C_ABI_32BIT != yes; then
+           # 64-bit or unknown ABI.
+           if test -d /usr/lib64; then
+             acl_libdirstem3=lib64
+           fi
+         fi
+         if test -n "$searchpath"; then
+           acl_save_IFS="${IFS= 	}"; IFS=":"
+           for searchdir in $searchpath; do
+             if test -d "$searchdir"; then
+               case "$searchdir" in
+                 */lib32/ | */lib32 ) acl_libdirstem2=lib32 ;;
+                 */lib64/ | */lib64 ) acl_libdirstem3=lib64 ;;
+                 */../ | */.. )
+                   # Better ignore directories of this form. They are misleading.
+                   ;;
+                 *) searchdir=`cd "$searchdir" && pwd`
+                    case "$searchdir" in
+                      */lib32 ) acl_libdirstem2=lib32 ;;
+                      */lib64 ) acl_libdirstem3=lib64 ;;
+                    esac ;;
+               esac
+             fi
+           done
+           IFS="$acl_save_IFS"
+           if test $HOST_CPU_C_ABI_32BIT = yes; then
+             # 32-bit ABI.
+             acl_libdirstem3=
+           fi
+           if test $HOST_CPU_C_ABI_32BIT = no; then
+             # 64-bit ABI.
+             acl_libdirstem2=
+           fi
+         fi
+         ;;
+     esac
+     test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem"
+     test -n "$acl_libdirstem3" || acl_libdirstem3="$acl_libdirstem"
+     acl_cv_libdirstems="$acl_libdirstem,$acl_libdirstem2,$acl_libdirstem3"
+    ])
+  dnl Decompose acl_cv_libdirstems into acl_libdirstem, acl_libdirstem2, and
+  dnl acl_libdirstem3.
+changequote(,)dnl
+  acl_libdirstem=`echo "$acl_cv_libdirstems" | sed -e 's/,.*//'`
+  acl_libdirstem2=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,//' -e 's/,.*//'`
+  acl_libdirstem3=`echo "$acl_cv_libdirstems" | sed -e 's/^[^,]*,[^,]*,//' -e 's/,.*//'`
+changequote([,])dnl
+])
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/nls.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/nls.m4
similarity index 77%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/nls.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/nls.m4
index b62f614..5a506fc 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/nls.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/nls.m4
@@ -1,16 +1,16 @@
-# nls.m4 serial 5 (gettext-0.18)
-dnl Copyright (C) 1995-2003, 2005-2006, 2008-2014, 2016, 2019 Free Software
-dnl Foundation, Inc.
+# nls.m4 serial 6 (gettext-0.20.2)
+dnl Copyright (C) 1995-2003, 2005-2006, 2008-2014, 2016, 2019-2020 Free
+dnl Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 dnl
 dnl This file can be used in projects which are not available under
-dnl the GNU General Public License or the GNU Library General Public
+dnl the GNU General Public License or the GNU Lesser General Public
 dnl License but which still want to provide support for the GNU gettext
 dnl functionality.
 dnl Please note that the actual code of the GNU gettext library is covered
-dnl by the GNU Library General Public License, and the rest of the GNU
+dnl by the GNU Lesser General Public License, and the rest of the GNU
 dnl gettext package is covered by the GNU General Public License.
 dnl They are *not* in the public domain.
 
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/po.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/po.m4
similarity index 98%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/po.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/po.m4
index 143792d..3778fd7 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/po.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/po.m4
@@ -1,15 +1,15 @@
-# po.m4 serial 30 (gettext-0.20)
-dnl Copyright (C) 1995-2014, 2016, 2018-2019 Free Software Foundation, Inc.
+# po.m4 serial 31 (gettext-0.20.2)
+dnl Copyright (C) 1995-2014, 2016, 2018-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 dnl
 dnl This file can be used in projects which are not available under
-dnl the GNU General Public License or the GNU Library General Public
+dnl the GNU General Public License or the GNU Lesser General Public
 dnl License but which still want to provide support for the GNU gettext
 dnl functionality.
 dnl Please note that the actual code of the GNU gettext library is covered
-dnl by the GNU Library General Public License, and the rest of the GNU
+dnl by the GNU Lesser General Public License, and the rest of the GNU
 dnl gettext package is covered by the GNU General Public License.
 dnl They are *not* in the public domain.
 
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/progtest.m4 b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/progtest.m4
similarity index 91%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/progtest.m4
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/progtest.m4
index 5f186b1..f28010a 100644
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/aclocal/progtest.m4
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/aclocal/progtest.m4
@@ -1,15 +1,15 @@
-# progtest.m4 serial 7 (gettext-0.18.2)
-dnl Copyright (C) 1996-2003, 2005, 2008-2019 Free Software Foundation, Inc.
+# progtest.m4 serial 8 (gettext-0.20.2)
+dnl Copyright (C) 1996-2003, 2005, 2008-2020 Free Software Foundation, Inc.
 dnl This file is free software; the Free Software Foundation
 dnl gives unlimited permission to copy and/or distribute it,
 dnl with or without modifications, as long as this notice is preserved.
 dnl
 dnl This file can be used in projects which are not available under
-dnl the GNU General Public License or the GNU Library General Public
+dnl the GNU General Public License or the GNU Lesser General Public
 dnl License but which still want to provide support for the GNU gettext
 dnl functionality.
 dnl Please note that the actual code of the GNU gettext library is covered
-dnl by the GNU Library General Public License, and the rest of the GNU
+dnl by the GNU Lesser General Public License, and the rest of the GNU
 dnl gettext package is covered by the GNU General Public License.
 dnl They are *not* in the public domain.
 
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/config.rpath b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/config.rpath
similarity index 99%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/config.rpath
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/config.rpath
index be202c1..24be79c 100755
--- a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/config.rpath
+++ b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/config.rpath
@@ -2,7 +2,7 @@
 # Output a system dependent set of variables, describing how to set the
 # run time search path of shared libraries in an executable.
 #
-#   Copyright 1996-2019 Free Software Foundation, Inc.
+#   Copyright 1996-2020 Free Software Foundation, Inc.
 #   Taken from GNU libtool, 2001
 #   Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 #
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/remove-potcdate.sin b/poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/remove-potcdate.sin
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-minimal-0.20.1/remove-potcdate.sin
rename to poky/meta/recipes-core/gettext/gettext-minimal-0.20.2/remove-potcdate.sin
diff --git a/poky/meta/recipes-core/gettext/gettext-minimal-native_0.20.1.bb b/poky/meta/recipes-core/gettext/gettext-minimal-native_0.20.2.bb
similarity index 100%
rename from poky/meta/recipes-core/gettext/gettext-minimal-native_0.20.1.bb
rename to poky/meta/recipes-core/gettext/gettext-minimal-native_0.20.2.bb
diff --git a/poky/meta/recipes-core/gettext/gettext_0.20.1.bb b/poky/meta/recipes-core/gettext/gettext_0.20.2.bb
similarity index 96%
rename from poky/meta/recipes-core/gettext/gettext_0.20.1.bb
rename to poky/meta/recipes-core/gettext/gettext_0.20.2.bb
index 85493e7..fda11c4 100644
--- a/poky/meta/recipes-core/gettext/gettext_0.20.1.bb
+++ b/poky/meta/recipes-core/gettext/gettext_0.20.2.bb
@@ -19,16 +19,14 @@
 SRC_URI = "${GNU_MIRROR}/gettext/gettext-${PV}.tar.gz \
            file://parallel.patch \
            file://add-with-bisonlocaledir.patch \
-           file://cr-statement.c-timsort.h-fix-formatting-issues.patch \
            file://use-pkgconfig.patch \
            file://run-ptest \
            file://serial-tests-config.patch \
-           file://0001-msgmerge-Fix-behaviour-of-for-msgfmt-on-PO-files-wit.patch \
            file://0001-tests-autopoint-3-unset-MAKEFLAGS.patch \
            file://0001-init-env.in-do-not-add-C-CXX-parameters.patch \
            "
-SRC_URI[md5sum] = "bb5b0c0caa028105f3ca1905ddc306e2"
-SRC_URI[sha256sum] = "66415634c6e8c3fa8b71362879ec7575e27da43da562c798a8a2f223e6e47f5c"
+SRC_URI[md5sum] = "30fec34a895fab4c02584449c500aac2"
+SRC_URI[sha256sum] = "ecb9d0908ca41d5ca5fef974323b3bba6bec19eebba0b44f396de98cfcc089f1"
 
 inherit autotools texinfo pkgconfig ptest
 
@@ -132,7 +130,7 @@
 	rm ${D}${datadir}/gettext/po/remove-potcdate.sin
 
         create_wrapper ${D}${bindir}/msgfmt \
-                GETTEXTDATADIR="${STAGING_DATADIR_NATIVE}/gettext-0.20/"
+                GETTEXTDATADIR="${STAGING_DATADIR_NATIVE}/gettext-0.20.2/"
 
 }
 
diff --git a/poky/meta/recipes-core/glib-2.0/glib-2.0/0001-meson-Don-t-misdetect-stpcpy-on-windows-platforms-on.patch b/poky/meta/recipes-core/glib-2.0/glib-2.0/0001-meson-Don-t-misdetect-stpcpy-on-windows-platforms-on.patch
deleted file mode 100644
index 855bdfc..0000000
--- a/poky/meta/recipes-core/glib-2.0/glib-2.0/0001-meson-Don-t-misdetect-stpcpy-on-windows-platforms-on.patch
+++ /dev/null
@@ -1,53 +0,0 @@
-From d4b1fd9cdb7ae07fa6be941ac95f97ece175fe55 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Martin=20Storsj=C3=B6?= <martin@martin.st>
-Date: Tue, 31 Mar 2020 23:54:17 +0300
-Subject: [PATCH] meson: Don't misdetect stpcpy on windows platforms on clang
-
-See https://github.com/mesonbuild/meson/issues/3672 and
-https://github.com/mesonbuild/meson/issues/5628 for explanations
-of cases where meson misdetects functions due to clang builtins (that
-always are available, regardless of whether the platform actually
-provides them).
-
-The same also happens on GCC 10, which added support for __has_builtin.
-
-Upstream-Status: Backport [https://github.com/GNOME/glib/commit/1b94bfbd72dbbfb696fa68f3742f40998096b438]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- meson.build | 16 +++++++++++++---
- 1 file changed, 13 insertions(+), 3 deletions(-)
-
-diff --git a/meson.build b/meson.build
-index 72ca194..bbdac1c 100644
---- a/meson.build
-+++ b/meson.build
-@@ -533,13 +533,23 @@ foreach f : functions
-   endif
- endforeach
- 
--# Check that stpcpy() is usable; must use header
--if cc.has_function('stpcpy', prefix : '#include <string.h>')
-+# Check that stpcpy() is usable; must use header.
-+# cc.has_function() in some cases (clang, gcc 10+) assumes that if the
-+# compiler provides a builtin of the same name that the function exists, while
-+# it's in fact not provided by any header or library. This is true for
-+# stpcpy() on Windows using clang and gcc as well as posix_memalign() using
-+# gcc on Windows. Skip these checks on Windows for now to avoid false
-+# positives. See https://github.com/mesonbuild/meson/pull/7116,
-+# https://github.com/mesonbuild/meson/issues/3672 and
-+# https://github.com/mesonbuild/meson/issues/5628.
-+# FIXME: Once meson no longer returns success for stpcpy() and
-+# posix_memalign() on Windows using GCC and clang we can remove this.
-+if host_system != 'windows' and cc.has_function('stpcpy', prefix : '#include <string.h>')
-   glib_conf.set('HAVE_STPCPY', 1)
- endif
- 
- # Check that posix_memalign() is usable; must use header
--if cc.has_function('posix_memalign', prefix : '#include <stdlib.h>')
-+if host_system != 'windows' and cc.has_function('posix_memalign', prefix : '#include <stdlib.h>')
-   glib_conf.set('HAVE_POSIX_MEMALIGN', 1)
- endif
- 
--- 
-2.26.2
-
diff --git a/poky/meta/recipes-core/glib-2.0/glib-2.0_2.64.2.bb b/poky/meta/recipes-core/glib-2.0/glib-2.0_2.64.3.bb
similarity index 89%
rename from poky/meta/recipes-core/glib-2.0/glib-2.0_2.64.2.bb
rename to poky/meta/recipes-core/glib-2.0/glib-2.0_2.64.3.bb
index d6207b5..2e5f7a0 100644
--- a/poky/meta/recipes-core/glib-2.0/glib-2.0_2.64.2.bb
+++ b/poky/meta/recipes-core/glib-2.0/glib-2.0_2.64.3.bb
@@ -16,13 +16,12 @@
            file://0001-Do-not-write-bindir-into-pkg-config-files.patch \
            file://0001-meson-Run-atomics-test-on-clang-as-well.patch \
            file://0001-gio-tests-resources.c-comment-out-a-build-host-only-.patch \
-           file://0001-meson-Don-t-misdetect-stpcpy-on-windows-platforms-on.patch \
            "
 
 SRC_URI_append_class-native = " file://relocate-modules.patch"
 
-SRC_URI[md5sum] = "78b6bda8664763a09bd12d864c0ba46c"
-SRC_URI[sha256sum] = "9a2f21ed8f13b9303399de13a0252b7cbcede593d26971378ec6cb90e87f2277"
+SRC_URI[md5sum] = "ccc48e58545cac45f5b3df3b8aeaff13"
+SRC_URI[sha256sum] = "fe9cbc97925d14c804935f067a3ad77ef55c0bbe9befe68962318f5a767ceb22"
 
 # Find any meson cross files in FILESPATH that are relevant for the current
 # build (using siteinfo) and add them to EXTRA_OEMESON.
diff --git a/poky/meta/recipes-core/glib-networking/glib-networking_2.64.2.bb b/poky/meta/recipes-core/glib-networking/glib-networking_2.64.3.bb
similarity index 87%
rename from poky/meta/recipes-core/glib-networking/glib-networking_2.64.2.bb
rename to poky/meta/recipes-core/glib-networking/glib-networking_2.64.3.bb
index 8300d20..a79e0e4 100644
--- a/poky/meta/recipes-core/glib-networking/glib-networking_2.64.2.bb
+++ b/poky/meta/recipes-core/glib-networking/glib-networking_2.64.3.bb
@@ -9,8 +9,8 @@
 SECTION = "libs"
 DEPENDS = "glib-2.0"
 
-SRC_URI[archive.md5sum] = "7f8c7ffe2616be4ef4232f2574353dab"
-SRC_URI[archive.sha256sum] = "45def0715c551f9b0b41a4e4f730ac95f3d5d4f3de8162260fbf9421cff695a7"
+SRC_URI[archive.md5sum] = "eb382907ec941fe2fb1a9676b75acf7a"
+SRC_URI[archive.sha256sum] = "937a06b124052813bfc0b0b86bff42016ff01067582e1aca65bb6dbe0845a168"
 
 PACKAGECONFIG ??= "gnutls"
 
diff --git a/poky/meta/recipes-core/images/core-image-minimal-initramfs.bb b/poky/meta/recipes-core/images/core-image-minimal-initramfs.bb
index 7df8ab1..83d0eaa 100644
--- a/poky/meta/recipes-core/images/core-image-minimal-initramfs.bb
+++ b/poky/meta/recipes-core/images/core-image-minimal-initramfs.bb
@@ -27,5 +27,5 @@
 IMAGE_ROOTFS_SIZE = "8192"
 IMAGE_ROOTFS_EXTRA_SPACE = "0"
 
-# Use the same restriction as initramfs-live-install
-COMPATIBLE_HOST = "(i.86|x86_64).*-linux"
+# Use the same restriction as initramfs-module-install
+COMPATIBLE_HOST = '(x86_64.*|i.86.*|arm.*|aarch64.*)-(linux.*|freebsd.*)'
diff --git a/poky/meta/recipes-core/initscripts/init-system-helpers_1.57.bb b/poky/meta/recipes-core/initscripts/init-system-helpers_1.57.bb
new file mode 100644
index 0000000..46f5bbf
--- /dev/null
+++ b/poky/meta/recipes-core/initscripts/init-system-helpers_1.57.bb
@@ -0,0 +1,41 @@
+SUMMARY = "helper tools for all init systems"
+DESCRIPTION = "This package contains helper tools that are necessary for switching between \
+the various init systems that Debian contains (e. g. sysvinit or \
+systemd). An example is deb-systemd-helper, a script that enables systemd unit \
+files without depending on a running systemd. \
+\
+It also includes the \"service\", \"invoke-rc.d\", and \"update-rc.d\" scripts which \
+provide an abstraction for enabling, disabling, starting, and stopping \
+services for all supported Debian init systems as specified by the policy. \
+\
+While this package is maintained by pkg-systemd-maintainers, it is NOT \
+specific to systemd at all. Maintainers of other init systems are welcome to \
+include their helpers in this package."
+HOMEPAGE = "https://salsa.debian.org/debian/init-system-helpers"
+SECTION = "base"
+LICENSE = "BSD-3-Clause & GPLv2"
+LIC_FILES_CHKSUM = "file://debian/copyright;md5=ee2b1830fcfead84d07bc060ec43e072"
+
+SRCREV = "760c625ec0e1ffebec2e391d891d389da0f65726"
+SRC_URI = "git://salsa.debian.org/debian/init-system-helpers.git"
+
+S = "${WORKDIR}/git"
+
+do_configure[noexec] = "1"
+do_compile[noexec] = "1"
+
+do_install() {
+	install -d -m 0755 ${D}${sbindir}
+	install -m 0755 ${S}/script/invoke-rc.d ${D}${sbindir}
+	install -m 0755 ${S}/script/service ${D}${sbindir}
+}
+
+PACKAGES += "${PN}-invoke-rc.d ${PN}-service"
+
+FILES_${PN} = ""
+FILES_${PN}-invoke-rc.d = "${sbindir}/invoke-rc.d"
+FILES_${PN}-service = "${sbindir}/service"
+
+ALLOW_EMPTY_${PN} = "1"
+
+RRECOMMENDS_${PN} += "${PN}-invoke-rc.d ${PN}-service"
diff --git a/poky/meta/recipes-core/initscripts/initscripts_1.0.bb b/poky/meta/recipes-core/initscripts/initscripts_1.0.bb
index 1a59b82..4080c4a 100644
--- a/poky/meta/recipes-core/initscripts/initscripts_1.0.bb
+++ b/poky/meta/recipes-core/initscripts/initscripts_1.0.bb
@@ -50,6 +50,7 @@
 PACKAGES =+ "${PN}-functions ${PN}-sushell"
 RDEPENDS_${PN} = "initd-functions \
                   ${@bb.utils.contains('DISTRO_FEATURES','selinux','${PN}-sushell','',d)} \
+                  init-system-helpers-service \
 		 "
 # Recommend pn-functions so that it will be a preferred default provider for initd-functions
 RRECOMMENDS_${PN} = "${PN}-functions"
diff --git a/poky/meta/recipes-core/sysfsutils/sysfsutils_2.1.0.bb b/poky/meta/recipes-core/sysfsutils/sysfsutils_2.1.0.bb
index f9f067d..34bf431 100644
--- a/poky/meta/recipes-core/sysfsutils/sysfsutils_2.1.0.bb
+++ b/poky/meta/recipes-core/sysfsutils/sysfsutils_2.1.0.bb
@@ -27,7 +27,5 @@
 
 PACKAGES =+ "libsysfs"
 FILES_libsysfs = "${libdir}/lib*${SOLIBS}"
-FILES_libsysfs-dev = "${libdir}/lib*${SOLIBSDEV} ${includedir}"
-FILES_libsysfs-staticdev = "${libdir}/lib*.a"
 
 export libdir = "${base_libdir}"
diff --git a/poky/meta/recipes-core/systemd/systemd-boot_245.5.bb b/poky/meta/recipes-core/systemd/systemd-boot_245.6.bb
similarity index 100%
rename from poky/meta/recipes-core/systemd/systemd-boot_245.5.bb
rename to poky/meta/recipes-core/systemd/systemd-boot_245.6.bb
diff --git a/poky/meta/recipes-core/systemd/systemd-conf_245.5.bb b/poky/meta/recipes-core/systemd/systemd-conf_245.6.bb
similarity index 100%
rename from poky/meta/recipes-core/systemd/systemd-conf_245.5.bb
rename to poky/meta/recipes-core/systemd/systemd-conf_245.6.bb
diff --git a/poky/meta/recipes-core/systemd/systemd.inc b/poky/meta/recipes-core/systemd/systemd.inc
index 0f82580..8c758ab 100644
--- a/poky/meta/recipes-core/systemd/systemd.inc
+++ b/poky/meta/recipes-core/systemd/systemd.inc
@@ -14,7 +14,7 @@
 LIC_FILES_CHKSUM = "file://LICENSE.GPL2;md5=751419260aa954499f7abaabaa882bbe \
                     file://LICENSE.LGPL2.1;md5=4fbd65380cdd255951079008b364516c"
 
-SRCREV = "9a506b7e9291d997a920af9ac299e7b834368119"
+SRCREV = "aa0cb635f1f6a4d9b50ed2cca7782f3f751be933"
 SRCBRANCH = "v245-stable"
 SRC_URI = "git://github.com/systemd/systemd-stable.git;protocol=git;branch=${SRCBRANCH}"
 
diff --git a/poky/meta/recipes-core/systemd/systemd/0001-binfmt-Don-t-install-dependency-links-at-install-tim.patch b/poky/meta/recipes-core/systemd/systemd/0001-binfmt-Don-t-install-dependency-links-at-install-tim.patch
index d098084..26f70b3 100644
--- a/poky/meta/recipes-core/systemd/systemd/0001-binfmt-Don-t-install-dependency-links-at-install-tim.patch
+++ b/poky/meta/recipes-core/systemd/systemd/0001-binfmt-Don-t-install-dependency-links-at-install-tim.patch
@@ -1,4 +1,4 @@
-From e9c993816077c1ae67d25d464f2ece2a090f30b8 Mon Sep 17 00:00:00 2001
+From 564830719be2017c4953589d50f21a9e856a4ecc Mon Sep 17 00:00:00 2001
 From: Chen Qi <Qi.Chen@windriver.com>
 Date: Thu, 21 Feb 2019 16:23:24 +0800
 Subject: [PATCH] binfmt: Don't install dependency links at install time for
@@ -61,7 +61,7 @@
 +[Install]
 +WantedBy=sysinit.target
 diff --git a/units/systemd-binfmt.service.in b/units/systemd-binfmt.service.in
-index 0c0f26451b67..763c4c466c16 100644
+index e54e95e11d5d..372a598614d3 100644
 --- a/units/systemd-binfmt.service.in
 +++ b/units/systemd-binfmt.service.in
 @@ -14,6 +14,7 @@ Documentation=https://www.kernel.org/doc/html/latest/admin-guide/binfmt-misc.htm
@@ -72,9 +72,9 @@
  After=proc-sys-fs-binfmt_misc.automount
  After=proc-sys-fs-binfmt_misc.mount
  Before=sysinit.target shutdown.target
-@@ -29,3 +30,6 @@ Type=oneshot
- RemainAfterExit=yes
+@@ -30,3 +31,6 @@ RemainAfterExit=yes
  ExecStart=@rootlibexecdir@/systemd-binfmt
+ ExecStop=@rootlibexecdir@/systemd-binfmt --unregister
  TimeoutSec=90s
 +
 +[Install]
diff --git a/poky/meta/recipes-core/systemd/systemd_245.5.bb b/poky/meta/recipes-core/systemd/systemd_245.6.bb
similarity index 100%
rename from poky/meta/recipes-core/systemd/systemd_245.5.bb
rename to poky/meta/recipes-core/systemd/systemd_245.6.bb
diff --git a/poky/meta/recipes-core/util-linux/util-linux.inc b/poky/meta/recipes-core/util-linux/util-linux.inc
index 0566569..532cceb 100644
--- a/poky/meta/recipes-core/util-linux/util-linux.inc
+++ b/poky/meta/recipes-core/util-linux/util-linux.inc
@@ -257,6 +257,7 @@
 ALTERNATIVE_LINK_NAME[renice] = "${bindir}/renice"
 ALTERNATIVE_LINK_NAME[rev] = "${bindir}/rev"
 ALTERNATIVE_LINK_NAME[rfkill] = "${sbindir}/rfkill"
+ALTERNATIVE_LINK_NAME[rtcwake] = "${sbindir}/rtcwake"
 ALTERNATIVE_LINK_NAME[setpriv] = "${bindir}/setpriv"
 ALTERNATIVE_LINK_NAME[setsid] = "${bindir}/setsid"
 ALTERNATIVE_LINK_NAME[su] = "${base_bindir}/su"
diff --git a/poky/meta/recipes-core/util-linux/util-linux/0001-hwclock-fix-for-glibc-2.31-settimeofday.patch b/poky/meta/recipes-core/util-linux/util-linux/0001-hwclock-fix-for-glibc-2.31-settimeofday.patch
deleted file mode 100644
index 0672c35..0000000
--- a/poky/meta/recipes-core/util-linux/util-linux/0001-hwclock-fix-for-glibc-2.31-settimeofday.patch
+++ /dev/null
@@ -1,112 +0,0 @@
-From ee85d3967ea09b215fcea5efdd90bbbf5e74a681 Mon Sep 17 00:00:00 2001
-From: Karel Zak <kzak@redhat.com>
-Date: Wed, 19 Feb 2020 15:50:47 +0100
-Subject: [PATCH] hwclock: fix for glibc 2.31 settimeofday()
-
-glibc announce:
-  ... settimeofday can no longer be used to set the time and the offset
-  simultaneously. If both of its two arguments are non-null, the call
-  will fail (setting errno to EINVAL).
-
-It means we need to call settimeofday(NULL, tz) and settimeofday(tv, NULL).
-
-Unfortunately, settimeofday(NULL, tz) has very special warp-clock
-semantic if used as the very first settimeofday() call. It means we
-have to be sure that we do not touch warp-clock if we need only need
-to modify system TZ. So, let's always call settimeofday(NULL, 0)
-before settimeofday(NULL, tz) for UTC rtc mode when modify system TZ.
-
-Upstream-Status: Backport [https://github.com/karelzak/util-linux/commit/ee85d3967ea09b215fcea5efdd90bbbf5e74a681]
-
-CC: J William Piggott <elseifthen@gmx.com>
-Signed-off-by: Karel Zak <kzak@redhat.com>
-Addresses: https://github.com/karelzak/util-linux/issues/957
-Signed-off-by: Liwei Song <liwei.song@windriver.com>
----
- sys-utils/hwclock.c | 49 ++++++++++++++++++++++++++-------------------
- 1 file changed, 28 insertions(+), 21 deletions(-)
-
-diff --git a/sys-utils/hwclock.c b/sys-utils/hwclock.c
-index e736da7179f8..16576bc186ff 100644
---- a/sys-utils/hwclock.c
-+++ b/sys-utils/hwclock.c
-@@ -658,6 +658,9 @@ display_time(struct timeval hwctime)
-  * PCIL: persistent_clock_is_local, sets the "11 minute mode" timescale.
-  * firsttime: locks the warp_clock function (initialized to 1 at boot).
-  *
-+ * Note that very first settimeofday(NULL, tz) modifies warp-clock as well as
-+ * system TZ.
-+ *
-  * +---------------------------------------------------------------------------+
-  * |  op     | RTC scale | settimeofday calls                                  |
-  * |---------|-----------|-----------------------------------------------------|
-@@ -675,41 +678,45 @@ set_system_clock(const struct hwclock_control *ctl,
- 	struct tm broken;
- 	int minuteswest;
- 	int rc = 0;
--	const struct timezone tz_utc = { 0 };
- 
- 	localtime_r(&newtime.tv_sec, &broken);
- 	minuteswest = -get_gmtoff(&broken) / 60;
- 
- 	if (ctl->verbose) {
--		if (ctl->hctosys && !ctl->universal)
--			printf(_("Calling settimeofday(NULL, %d) to set "
--				 "persistent_clock_is_local.\n"), minuteswest);
--		if (ctl->systz && ctl->universal)
-+		if (ctl->universal)
- 			puts(_("Calling settimeofday(NULL, 0) "
--				"to lock the warp function."));
-+			       "to lock the warp function."));
-+		else
-+			printf(_("Calling settimeofday(NULL, %d) to set "
-+				 "persistent_clock_is_local and "
-+				 "the kernel timezone.\n"), minuteswest);
-+
-+		if (ctl->universal && minuteswest)
-+			printf(_("Calling settimeofday(NULL, %d) to set "
-+				 "the kernel timezone.\n"), minuteswest);
-+
- 		if (ctl->hctosys)
--			printf(_("Calling settimeofday(%ld.%06ld, %d)\n"),
--			       newtime.tv_sec, newtime.tv_usec, minuteswest);
--		else {
--			printf(_("Calling settimeofday(NULL, %d) "), minuteswest);
--			if (ctl->universal)
--				 puts(_("to set the kernel timezone."));
--			else
--				 puts(_("to warp System time."));
--		}
-+			printf(_("Calling settimeofday(%ld.%06ld, 0) to set "
-+			         "the kernel time.\n"), newtime.tv_sec, newtime.tv_usec);
- 	}
- 
- 	if (!ctl->testing) {
-+		const struct timezone tz_utc = { 0 };
- 		const struct timezone tz = { minuteswest };
- 
--		if (ctl->hctosys && !ctl->universal)	/* set PCIL */
-+		/* warp-clock */
-+		if (ctl->universal)
-+			rc = settimeofday(NULL, &tz_utc); /* lock to UTC */
-+		else
-+			rc = settimeofday(NULL, &tz);     /* set PCIL and TZ */
-+
-+		/* set timezone */
-+		if (!rc && ctl->universal && minuteswest)
- 			rc = settimeofday(NULL, &tz);
--		if (ctl->systz && ctl->universal)	/* lock warp_clock */
--			rc = settimeofday(NULL, &tz_utc);
-+
-+		/* set time */
- 		if (!rc && ctl->hctosys)
--			rc = settimeofday(&newtime, &tz);
--		else if (!rc)
--			rc = settimeofday(NULL, &tz);
-+			rc = settimeofday(&newtime, NULL);
- 
- 		if (rc) {
- 			warn(_("settimeofday() failed"));
--- 
-2.17.1
-
diff --git a/poky/meta/recipes-core/util-linux/util-linux/0001-kill-include-sys-types.h-before-checking-SYS_pidfd_s.patch b/poky/meta/recipes-core/util-linux/util-linux/0001-kill-include-sys-types.h-before-checking-SYS_pidfd_s.patch
deleted file mode 100644
index e43e128..0000000
--- a/poky/meta/recipes-core/util-linux/util-linux/0001-kill-include-sys-types.h-before-checking-SYS_pidfd_s.patch
+++ /dev/null
@@ -1,64 +0,0 @@
-From 3cfde0370d3a8949df0c5bcf447cec6692910ed2 Mon Sep 17 00:00:00 2001
-From: Sami Kerola <kerolasa@iki.fi>
-Date: Sat, 15 Feb 2020 21:12:50 +0000
-Subject: [PATCH] kill: include sys/types.h before checking
- SYS_pidfd_send_signal
-
-Including sys/types.h must happen before SYS_pidfd_send_signal is checked,
-because that header defines variable in normal conditions.  When sys/types.h
-does not have SYS_pidfd_send_signal then fallback is defined in config.h
-that is included by default, and has therefore worked fine before and after
-this change.
-
-Upstream-Status: Backport [https://github.com/karelzak/util-linux/commit/3cfde0370d3a8949df0c5bcf447cec6692910ed2]
-
-Signed-off-by: Sami Kerola <kerolasa@iki.fi>
-Signed-off-by: Benjamin Fair <benjaminfair@google.com>
----
- include/pidfd-utils.h | 18 ++++++++++--------
- 1 file changed, 10 insertions(+), 8 deletions(-)
-
-diff --git a/include/pidfd-utils.h b/include/pidfd-utils.h
-index 593346576..0baedd2c9 100644
---- a/include/pidfd-utils.h
-+++ b/include/pidfd-utils.h
-@@ -1,26 +1,28 @@
- #ifndef UTIL_LINUX_PIDFD_UTILS
- #define UTIL_LINUX_PIDFD_UTILS
- 
--#if defined(__linux__) && defined(SYS_pidfd_send_signal)
--# include <sys/types.h>
-+#if defined(__linux__)
- # include <sys/syscall.h>
-+# if defined(SYS_pidfd_send_signal)
-+#  include <sys/types.h>
- 
--# ifndef HAVE_PIDFD_OPEN
-+#  ifndef HAVE_PIDFD_OPEN
- static inline int pidfd_send_signal(int pidfd, int sig, siginfo_t *info,
- 				    unsigned int flags)
- {
- 	return syscall(SYS_pidfd_send_signal, pidfd, sig, info, flags);
- }
--# endif
-+#  endif
- 
--# ifndef HAVE_PIDFD_SEND_SIGNAL
-+#  ifndef HAVE_PIDFD_SEND_SIGNAL
- static inline int pidfd_open(pid_t pid, unsigned int flags)
- {
- 	return syscall(SYS_pidfd_open, pid, flags);
- }
--# endif
-+#  endif
- 
--# define UL_HAVE_PIDFD 1
-+#  define UL_HAVE_PIDFD 1
- 
--#endif /* __linux__ && SYS_pidfd_send_signal */
-+# endif	/* SYS_pidfd_send_signal */
-+#endif /* __linux__ */
- #endif /* UTIL_LINUX_PIDFD_UTILS */
--- 
-2.26.1.301.g55bc3eb7cb9-goog
-
diff --git a/poky/meta/recipes-core/util-linux/util-linux/0001-libfdisk-script-accept-sector-size-ignore-unknown-he.patch b/poky/meta/recipes-core/util-linux/util-linux/0001-libfdisk-script-accept-sector-size-ignore-unknown-he.patch
deleted file mode 100644
index 911f70b..0000000
--- a/poky/meta/recipes-core/util-linux/util-linux/0001-libfdisk-script-accept-sector-size-ignore-unknown-he.patch
+++ /dev/null
@@ -1,137 +0,0 @@
-From 00e53f17c8462cb34ece08cc10db60a7da29a305 Mon Sep 17 00:00:00 2001
-From: Karel Zak <kzak@redhat.com>
-Date: Tue, 4 Feb 2020 15:11:19 +0100
-Subject: [PATCH] libfdisk: (script) accept sector-size, ignore unknown headers
-
-- add sector-size between supported headers (already in --dump output)
-
-- report unknown headers by -ENOTSUP
-
-- ignore ENOTSUP in sfdisk (but print warning) and in fdisk_script_read_file()
-
-Upstream-Status: Backport [https://github.com/karelzak/util-linux/commit/00e53f17c8462cb34ece08cc10db60a7da29a305]
-
-Addresses: https://github.com/karelzak/util-linux/issues/949
-Signed-off-by: Karel Zak <kzak@redhat.com>
-Signed-off-by: Pierre-Jean Texier <pjtexier@koncepto.io>
----
- disk-utils/sfdisk.c   |  6 +++++-
- libfdisk/src/script.c | 49 ++++++++++++++++++++++++++-----------------------
- 2 files changed, 31 insertions(+), 24 deletions(-)
-
-diff --git a/disk-utils/sfdisk.c b/disk-utils/sfdisk.c
-index bb6e1c6..c0bea70 100644
---- a/disk-utils/sfdisk.c
-+++ b/disk-utils/sfdisk.c
-@@ -1782,7 +1782,11 @@ static int command_fdisk(struct sfdisk *sf, int argc, char **argv)
- 		}
- 
- 		rc = fdisk_script_read_line(dp, stdin, buf, sizeof(buf));
--		if (rc < 0) {
-+		if (rc == -ENOTSUP) {
-+			buf[sizeof(buf) - 1] = '\0';
-+			fdisk_warnx(sf->cxt, _("Unknown script header '%s' -- ignore."), buf);
-+			continue;
-+		} else if (rc < 0) {
- 			DBG(PARSE, ul_debug("script parsing failed, trying sfdisk specific commands"));
- 			buf[sizeof(buf) - 1] = '\0';
- 			rc = loop_control_commands(sf, dp, buf);
-diff --git a/libfdisk/src/script.c b/libfdisk/src/script.c
-index a21771b..d3e67fa 100644
---- a/libfdisk/src/script.c
-+++ b/libfdisk/src/script.c
-@@ -805,8 +805,12 @@ static inline int is_header_line(const char *s)
- /* parses "<name>: value", note modifies @s*/
- static int parse_line_header(struct fdisk_script *dp, char *s)
- {
--	int rc = -EINVAL;
-+	size_t i;
- 	char *name, *value;
-+	static const char *supported[] = {
-+		"label", "unit", "label-id", "device", "grain",
-+		"first-lba", "last-lba", "table-length", "sector-size"
-+	};
- 
- 	DBG(SCRIPT, ul_debugobj(dp, "   parse header '%s'", s));
- 
-@@ -816,7 +820,7 @@ static int parse_line_header(struct fdisk_script *dp, char *s)
- 	name = s;
- 	value = strchr(s, ':');
- 	if (!value)
--		goto done;
-+		return -EINVAL;
- 	*value = '\0';
- 	value++;
- 
-@@ -825,32 +829,30 @@ static int parse_line_header(struct fdisk_script *dp, char *s)
- 	ltrim_whitespace((unsigned char *) value);
- 	rtrim_whitespace((unsigned char *) value);
- 
-+	if (!*name || !*value)
-+		return -EINVAL;
-+
-+	/* check header name */
-+	for (i = 0; i < ARRAY_SIZE(supported); i++) {
-+		if (strcmp(name, supported[i]) == 0)
-+			break;
-+	}
-+	if (i == ARRAY_SIZE(supported))
-+		return -ENOTSUP;
-+
-+	/* header specific actions */
- 	if (strcmp(name, "label") == 0) {
- 		if (dp->cxt && !fdisk_get_label(dp->cxt, value))
--			goto done;			/* unknown label name */
-+			return -EINVAL;			/* unknown label name */
- 		dp->force_label = 1;
-+
- 	} else if (strcmp(name, "unit") == 0) {
- 		if (strcmp(value, "sectors") != 0)
--			goto done;			/* only "sectors" supported */
--	} else if (strcmp(name, "label-id") == 0
--		   || strcmp(name, "device") == 0
--		   || strcmp(name, "grain") == 0
--		   || strcmp(name, "first-lba") == 0
--		   || strcmp(name, "last-lba") == 0
--		   || strcmp(name, "table-length") == 0) {
--		;					/* whatever is possible */
--	} else
--		goto done;				/* unknown header */
-+			return -EINVAL;			/* only "sectors" supported */
- 
--	if (*name && *value)
--		rc = fdisk_script_set_header(dp, name, value);
--done:
--	if (rc)
--		DBG(SCRIPT, ul_debugobj(dp, "header parse error: "
--				"[rc=%d, name='%s', value='%s']",
--				rc, name, value));
--	return rc;
-+	}
- 
-+	return fdisk_script_set_header(dp, name, value);
- }
- 
- /* returns zero terminated string with next token and @str is updated */
-@@ -1363,7 +1365,8 @@ int fdisk_script_set_fgets(struct fdisk_script *dp,
-  *
-  * Reads next line into dump.
-  *
-- * Returns: 0 on success, <0 on error, 1 when nothing to read.
-+ * Returns: 0 on success, <0 on error, 1 when nothing to read. For unknown headers
-+ *          returns -ENOTSUP, it's usually safe to ignore this error.
-  */
- int fdisk_script_read_line(struct fdisk_script *dp, FILE *f, char *buf, size_t bufsz)
- {
-@@ -1428,7 +1431,7 @@ int fdisk_script_read_file(struct fdisk_script *dp, FILE *f)
- 
- 	while (!feof(f)) {
- 		rc = fdisk_script_read_line(dp, f, buf, sizeof(buf));
--		if (rc)
-+		if (rc && rc != -ENOTSUP)
- 			break;
- 	}
- 
--- 
-2.7.4
-
diff --git a/poky/meta/recipes-core/util-linux/util-linux_2.35.1.bb b/poky/meta/recipes-core/util-linux/util-linux_2.35.1.bb
deleted file mode 100644
index 516b783..0000000
--- a/poky/meta/recipes-core/util-linux/util-linux_2.35.1.bb
+++ /dev/null
@@ -1,16 +0,0 @@
-require util-linux.inc
-
-SRC_URI += "file://configure-sbindir.patch \
-            file://runuser.pamd \
-            file://runuser-l.pamd \
-            file://ptest.patch \
-            file://run-ptest \
-            file://display_testname_for_subtest.patch \
-            file://avoid_parallel_tests.patch \
-            file://0001-hwclock-fix-for-glibc-2.31-settimeofday.patch \
-            file://0001-libfdisk-script-accept-sector-size-ignore-unknown-he.patch \
-            file://0001-kill-include-sys-types.h-before-checking-SYS_pidfd_s.patch \
-            file://0001-include-cleanup-pidfd-inckudes.patch \
-"
-SRC_URI[md5sum] = "7f64882f631225f0295ca05080cee1bf"
-SRC_URI[sha256sum] = "d9de3edd287366cd908e77677514b9387b22bc7b88f45b83e1922c3597f1d7f9"
diff --git a/poky/meta/recipes-core/util-linux/util-linux_2.35.2.bb b/poky/meta/recipes-core/util-linux/util-linux_2.35.2.bb
new file mode 100644
index 0000000..752a6fa
--- /dev/null
+++ b/poky/meta/recipes-core/util-linux/util-linux_2.35.2.bb
@@ -0,0 +1,13 @@
+require util-linux.inc
+
+SRC_URI += "file://configure-sbindir.patch \
+            file://runuser.pamd \
+            file://runuser-l.pamd \
+            file://ptest.patch \
+            file://run-ptest \
+            file://display_testname_for_subtest.patch \
+            file://avoid_parallel_tests.patch \
+            file://0001-include-cleanup-pidfd-inckudes.patch \
+"
+SRC_URI[md5sum] = "248a4d0810c9193e0e9a4bb3f26b93d8"
+SRC_URI[sha256sum] = "21b7431e82f6bcd9441a01beeec3d57ed33ee948f8a5b41da577073c372eb58a"
diff --git a/poky/meta/recipes-devtools/apt/apt-native.inc b/poky/meta/recipes-devtools/apt/apt-native.inc
deleted file mode 100644
index d826786..0000000
--- a/poky/meta/recipes-devtools/apt/apt-native.inc
+++ /dev/null
@@ -1,74 +0,0 @@
-require apt.inc
-inherit native
-
-DEPENDS += "dpkg-native gettext-native db-native curl-native xz-native"
-PACKAGES = ""
-USE_NLS = "yes"
-
-SRC_URI += "file://db_linking_hack.patch \
-            file://0001-Revert-always-run-dpkg-configure-a-at-the-end-of-our.patch \
-"
-
-python do_install () {
-    bb.build.exec_func('do_install_base', d)
-    bb.build.exec_func('do_install_config', d)
-}
-
-python do_install_config () {
-    indir = os.path.dirname(d.getVar('FILE'))
-    infile = open(oe.path.join(indir, 'files', 'apt.conf'), 'r')
-    data = infile.read()
-    infile.close()
-
-    data = d.expand(data)
-
-    outdir = oe.path.join(d.getVar('D'), d.getVar('sysconfdir'), 'apt')
-    if not os.path.exists(outdir):
-        os.makedirs(outdir)
-
-    outpath = oe.path.join(outdir, 'apt.conf.sample')
-    if not os.path.exists(outpath):
-        outfile = open(outpath, 'w')
-        outfile.write(data)
-        outfile.close()
-}
-
-do_install_base () {
-	install -d ${D}${bindir}
-	install -m 0755 bin/apt-cdrom ${D}${bindir}/
-	install -m 0755 bin/apt-get ${D}${bindir}/
-	install -m 0755 bin/apt-config ${D}${bindir}/
-	install -m 0755 bin/apt-cache ${D}${bindir}/
-	install -m 0755 bin/apt-sortpkgs ${D}${bindir}/
-	install -m 0755 bin/apt-extracttemplates ${D}${bindir}/
-	install -m 0755 bin/apt-ftparchive ${D}${bindir}/
-
-	oe_libinstall -so -C bin libapt-private ${D}${libdir}/
-
-	oe_libinstall -so -C bin libapt-pkg$GLIBC_VER$LIBSTDCPP_VER ${D}${libdir}/
-	oe_libinstall -so -C bin libapt-inst$GLIBC_VER$LIBSTDCPP_VER ${D}${libdir}/
-
-	install -d ${D}${libdir}/apt/methods
-	install -m 0755 bin/methods/* ${D}${libdir}/apt/methods/
-
-	install -d ${D}${libdir}/dpkg/methods/apt
-	install -m 0644 ${S}/dselect/desc.apt ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0644 ${S}/dselect/names ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0755 ${S}/dselect/install ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0755 ${S}/dselect/setup ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0755 ${S}/dselect/update ${D}${libdir}/dpkg/methods/apt/ 
-
-	install -d ${D}${sysconfdir}/apt
-	install -d ${D}${sysconfdir}/apt/apt.conf.d
-	install -d ${D}${sysconfdir}/apt/preferences.d
-	install -d ${D}${localstatedir}/lib/apt/lists/partial
-	install -d ${D}${localstatedir}/cache/apt/archives/partial
-
-	install -d ${D}${localstatedir}/log/apt/
-
-	install -d ${D}${includedir}/apt-pkg
-	for h in `find ${S}/apt-pkg ${S}/apt-inst -name '*.h'`
-	do
-		install -m 0644 $h ${D}${includedir}/apt-pkg
-	done
-}
diff --git a/poky/meta/recipes-devtools/apt/apt-native_1.2.31.bb b/poky/meta/recipes-devtools/apt/apt-native_1.2.31.bb
deleted file mode 100644
index 2952c21..0000000
--- a/poky/meta/recipes-devtools/apt/apt-native_1.2.31.bb
+++ /dev/null
@@ -1,5 +0,0 @@
-require apt-native.inc
-
-SRC_URI += "file://noconfigure.patch \
-            file://no-curl.patch \
-"
diff --git a/poky/meta/recipes-devtools/apt/apt-package.inc b/poky/meta/recipes-devtools/apt/apt-package.inc
deleted file mode 100644
index 922f739..0000000
--- a/poky/meta/recipes-devtools/apt/apt-package.inc
+++ /dev/null
@@ -1,94 +0,0 @@
-apt-manpages="doc/apt-cache.8 \
-	      doc/apt-cdrom.8 \
-	      doc/apt-config.8 \
-	      doc/apt-get.8 \
-	      doc/apt.8 \
-	      doc/apt.conf.5 \
-	      doc/apt_preferences.5 \
-	      doc/sources.list.5"
-apt-utils-manpages="doc/apt-extracttemplates.1 \
-		    doc/apt-sortpkgs.1"
-
-def get_files_apt_doc(d, bb, manpages):
-    import re
-    manpages = re.sub(r'\bdoc/(\S+)/(\S+)\.\1\.(.)\b', r'${mandir}/\1/man\3/\2.\3', manpages)
-    manpages = re.sub(r'\bdoc/(\S+)\.(.)\b', r'${mandir}/man\2/\1.\2', manpages)
-    return manpages
-
-def get_commands_apt_doc(d, bb, manpages):
-    s = list()
-    __dir_cache__ = list()
-    for m in manpages.split():
-        dest = get_files_apt_doc(d, bb, m)
-        dir = os.path.dirname(dest)
-        if not dir in __dir_cache__:
-            s.append("install -d ${D}/%s" % dir)
-            __dir_cache__.append(dir)
-        s.append("install -m 0644 %s ${D}/%s" % (m, dest))
-    return "\n".join(s)
-
-PACKAGES += "${PN}-utils ${PN}-utils-doc"
-FILES_${PN} = "${bindir}/apt-cdrom ${bindir}/apt-get \
-	       ${bindir}/apt-config ${bindir}/apt-cache \
-	       ${libdir}/apt ${libdir}/libapt*.so.* \
-	       ${localstatedir} ${sysconfdir} \
-	       ${libdir}/dpkg \
-	       ${systemd_unitdir}/system \
-           "
-RDEPENDS_${PN} += "perl"
-FILES_${PN}-utils = "${bindir}/apt-sortpkgs ${bindir}/apt-extracttemplates"
-FILES_${PN}-doc = "${@get_files_apt_doc(d, bb, d.getVar('apt-manpages'))} \
-		   ${docdir}/apt"
-FILES_${PN}-utils-doc = "${@get_files_apt_doc(d, bb, d.getVar('apt-utils-manpages'))}"
-FILES_${PN}-dev = "${libdir}/libapt*.so ${includedir}"
-
-inherit systemd
-
-SYSTEMD_SERVICE_${PN} = "apt-daily.timer"
-
-do_install () {
-	set -x
-	install -d ${D}${bindir}
-	install -m 0755 bin/apt-key ${D}${bindir}/
-	install -m 0755 bin/apt-cdrom ${D}${bindir}/
-	install -m 0755 bin/apt-get ${D}${bindir}/
-	install -m 0755 bin/apt-config ${D}${bindir}/
-	install -m 0755 bin/apt-cache ${D}${bindir}/
-
-	install -m 0755 bin/apt-sortpkgs ${D}${bindir}/
-	install -m 0755 bin/apt-extracttemplates ${D}${bindir}/
-
-	oe_libinstall -so -C bin libapt-pkg ${D}${libdir}
-	oe_libinstall -so -C bin libapt-inst ${D}${libdir}
-
-	install -d ${D}${libdir}/apt/methods
-	install -m 0755 bin/methods/* ${D}${libdir}/apt/methods/
-
-	install -d ${D}${libdir}/dpkg/methods/apt
-	install -m 0644 ${S}/dselect/desc.apt ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0644 ${S}/dselect/names ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0755 ${S}/dselect/install ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0755 ${S}/dselect/setup ${D}${libdir}/dpkg/methods/apt/ 
-	install -m 0755 ${S}/dselect/update ${D}${libdir}/dpkg/methods/apt/ 
-
-	install -d ${D}${sysconfdir}/apt
-	install -d ${D}${sysconfdir}/apt/apt.conf.d
-	install -d ${D}${sysconfdir}/apt/sources.list.d
-	install -d ${D}${sysconfdir}/apt/preferences.d
-	install -d ${D}${localstatedir}/lib/apt/lists/partial
-	install -d ${D}${localstatedir}/cache/apt/archives/partial
-	install -d ${D}${docdir}/apt/examples
-	install -m 0644 ${S}/doc/examples/* ${D}${docdir}/apt/examples/
-
-	install -d ${D}${includedir}/apt-pkg/
-	install -m 0644 include/apt-pkg/*.h ${D}${includedir}/apt-pkg/
-
-	install -d ${D}${systemd_unitdir}/system/
-	install -m 0755 ${S}/debian/apt.systemd.daily ${D}${libdir}/apt/
-	install -m 0644 ${S}/debian/apt-daily.service ${D}${systemd_unitdir}/system/
-	sed -i 's#/usr/lib/apt/#${libdir}/apt/#g' ${D}${systemd_unitdir}/system/apt-daily.service
-	install -m 0644 ${S}/debian/apt-daily.timer ${D}${systemd_unitdir}/system/
-	install -d ${D}${sysconfdir}/cron.daily/
-	install -m 0755 ${S}/debian/apt.apt-compat.cron.daily ${D}${sysconfdir}/cron.daily/
-	sed -i 's#/usr/lib/apt/#${libdir}/apt/#g' ${D}${sysconfdir}/cron.daily/apt.apt-compat.cron.daily
-}
diff --git a/poky/meta/recipes-devtools/apt/apt.inc b/poky/meta/recipes-devtools/apt/apt.inc
deleted file mode 100644
index 87d5337..0000000
--- a/poky/meta/recipes-devtools/apt/apt.inc
+++ /dev/null
@@ -1,40 +0,0 @@
-SUMMARY = "Advanced front-end for dpkg"
-DESCRIPTION = "Provides command-line tools for searching and managing as well \
-as querying information about packages as a low-level access to all features \
-of the libapt-pkg library."
-LICENSE = "GPLv2.0+"
-SECTION = "base"
-
-SRC_URI = "https://launchpad.net/ubuntu/+archive/primary/+sourcefiles/${BPN}/${PV}/${BPN}_${PV}.tar.xz \
-           file://use-host.patch \
-           file://makerace.patch \
-           file://no-nls-dpkg.patch \
-           file://fix-gcc-4.6-null-not-defined.patch \
-           file://truncate-filename.patch \
-           file://nodoc.patch \
-           file://disable-configure-in-makefile.patch \
-           file://disable-test.patch \
-           file://0001-environment.mak-musl-based-systems-can-generate-shar.patch \
-           file://0001-apt-1.2.12-Fix-musl-build.patch \
-           file://0001-Include-array.h-for-std-array.patch \
-           file://0001-The-C.UTF-8-locale-is-not-portable-use-std-locale-cl.patch \
-           "
-SRC_URI[md5sum] = "d30eed9304e82ea8238c854b5c5a34d9"
-SRC_URI[sha256sum] = "03ded4f5e9b8d43ecec083704b2dcabf20c182ed382db9ac7251da0b0b038059"
-LIC_FILES_CHKSUM = "file://COPYING.GPL;md5=b234ee4d69f5fce4486a80fdaf4a4263"
-
-# the package is taken from snapshots.debian.org; that source is static and goes stale
-# so we check the latest upstream from a directory that does get updated
-UPSTREAM_CHECK_URI = "${DEBIAN_MIRROR}/main/a/apt/"
-
-inherit autotools gettext useradd upstream-version-is-even
-
-EXTRA_AUTORECONF = "--exclude=autopoint,autoheader"
-
-do_configure_prepend() {
-    rm -rf ${S}/buildlib/config.sub
-    rm -rf ${S}/buildlib/config.guess
-}
-
-USERADD_PACKAGES = "${PN}"
-USERADD_PARAM_${PN} = "--system --no-create-home --home-dir /nonexistent --shell /bin/false --user-group _apt"
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-CMakeLists.txt-avoid-changing-install-paths-based-on.patch b/poky/meta/recipes-devtools/apt/apt/0001-CMakeLists.txt-avoid-changing-install-paths-based-on.patch
new file mode 100644
index 0000000..199f11b
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt/0001-CMakeLists.txt-avoid-changing-install-paths-based-on.patch
@@ -0,0 +1,29 @@
+From 9023589317843df4e57f8ebef1d9a8398ddb929d Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Thu, 28 May 2020 15:34:05 +0000
+Subject: [PATCH] CMakeLists.txt: avoid changing install paths based on host
+ distro
+
+Upstream-Status: Inappropriate [oe-core specific]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+---
+ CMakeLists.txt | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 2cd4f8e..4759812 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -21,9 +21,9 @@ set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "-lgcov")
+ set(CMAKE_SHARED_LINKER_FLAGS_COVERAGE "-lgcov")
+ 
+ # Work around bug in GNUInstallDirs
+-if (EXISTS "/etc/debian_version")
+-  set(CMAKE_INSTALL_LIBEXECDIR "lib")
+-endif()
++#if (EXISTS "/etc/debian_version")
++set(CMAKE_INSTALL_LIBEXECDIR "lib")
++#endif()
+ 
+ # Include stuff
+ include(Misc)
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-Disable-documentation-directory-altogether.patch b/poky/meta/recipes-devtools/apt/apt/0001-Disable-documentation-directory-altogether.patch
new file mode 100644
index 0000000..cc422b7
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt/0001-Disable-documentation-directory-altogether.patch
@@ -0,0 +1,27 @@
+From cd164b353ba7958d51b2f33f4079fb9787c983e2 Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Fri, 10 May 2019 14:16:47 +0200
+Subject: [PATCH] Disable documentation directory altogether
+
+Even when WITH_DOC=False, the build requires po4a to generate manpages.
+
+Upstream-Status: Inappropriate [oe-core specific]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+
+---
+ CMakeLists.txt | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 83334ba..2cd4f8e 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -232,7 +232,7 @@ add_subdirectory(apt-private)
+ add_subdirectory(apt-inst)
+ add_subdirectory(cmdline)
+ add_subdirectory(completions)
+-add_subdirectory(doc)
++#add_subdirectory(doc)
+ add_subdirectory(dselect)
+ add_subdirectory(ftparchive)
+ add_subdirectory(methods)
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-Do-not-configure-packages-on-installation.patch b/poky/meta/recipes-devtools/apt/apt/0001-Do-not-configure-packages-on-installation.patch
new file mode 100644
index 0000000..2322bd8
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt/0001-Do-not-configure-packages-on-installation.patch
@@ -0,0 +1,48 @@
+From 1ad21140787a6b8b0f774f75b50444d2c30a56f6 Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Thu, 21 May 2020 20:28:12 +0000
+Subject: [PATCH] Do not configure packages on installation
+
+This is done separately in do_rootfs().
+
+Upstream-Status: Inappropriate [oe-core specific]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+
+---
+ apt-pkg/packagemanager.cc | 5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/apt-pkg/packagemanager.cc b/apt-pkg/packagemanager.cc
+index 156f7ad..0f6a87c 100644
+--- a/apt-pkg/packagemanager.cc
++++ b/apt-pkg/packagemanager.cc
+@@ -1013,10 +1013,12 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
+       return false;
+ 
+    if (Immediate == true) {
++#if 0
+       // Perform immediate configuration of the package. 
+          if (SmartConfigure(Pkg, Depth + 1) == false)
+             _error->Error(_("Could not perform immediate configuration on '%s'. "
+                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);
++#endif
+    }
+    
+    return true;
+@@ -1111,6 +1113,7 @@ pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
+       }
+    }
+ 
++#if 0
+    // Final run through the configure phase
+    if (ConfigureAll() == false)
+       return Failed;
+@@ -1125,7 +1128,7 @@ pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
+ 	 return Failed;
+       }
+    }
+-	 
++#endif	 
+    return Completed;
+ }
+ // PM::DoInstallPostFork - compat /*{{{*/
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-Do-not-init-tables-from-dpkg-configuration.patch b/poky/meta/recipes-devtools/apt/apt/0001-Do-not-init-tables-from-dpkg-configuration.patch
new file mode 100644
index 0000000..d3d3ab0
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt/0001-Do-not-init-tables-from-dpkg-configuration.patch
@@ -0,0 +1,29 @@
+From b18d7aa7d71b53b86bac21cd1d8c3accabb28f2b Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Fri, 10 May 2019 16:47:38 +0200
+Subject: [PATCH] Do not init tables from dpkg configuration
+
+This would require sysroot relocation logic, and it's easier to just disable them.
+
+Upstream-Status: Inappropriate [oe-core specific]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+
+---
+ apt-pkg/init.cc | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/apt-pkg/init.cc b/apt-pkg/init.cc
+index a619368..6e5a6cf 100644
+--- a/apt-pkg/init.cc
++++ b/apt-pkg/init.cc
+@@ -281,8 +281,8 @@ bool pkgInitSystem(Configuration &Cnf,pkgSystem *&Sys)
+ 	 return _error->Error(_("Unable to determine a suitable packaging system type"));
+    }
+ 
+-   if (pkgInitArchTupleMap() == false)
+-      return false;
++//   if (pkgInitArchTupleMap() == false)
++//      return false;
+    
+    return Sys->Initialize(Cnf);
+ }
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-Fix-musl-build.patch b/poky/meta/recipes-devtools/apt/apt/0001-Fix-musl-build.patch
new file mode 100644
index 0000000..a6e8ef1
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt/0001-Fix-musl-build.patch
@@ -0,0 +1,45 @@
+From 081c6be2f2f1cd77f399ea414f8d89c107826624 Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Fri, 22 May 2020 15:29:23 +0000
+Subject: [PATCH] Fix musl build
+
+methods/connect.cc: Musl doesn't support AI_IDN flag in netdb.h
+header so define it manually.
+apt-pkg/contrib/srvrec.h: Add explicity include of sys/types.h
+to avoid errors in types u_int_SIZE.
+
+Upstream-Status: Pending
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+---
+ apt-pkg/contrib/srvrec.h | 1 +
+ methods/connect.cc       | 5 +++++
+ 2 files changed, 6 insertions(+)
+
+diff --git a/apt-pkg/contrib/srvrec.h b/apt-pkg/contrib/srvrec.h
+index e22b7a1..b1115f5 100644
+--- a/apt-pkg/contrib/srvrec.h
++++ b/apt-pkg/contrib/srvrec.h
+@@ -9,6 +9,7 @@
+ #ifndef SRVREC_H
+ #define SRVREC_H
+ 
++#include <sys/types.h>
+ #include <string>
+ #include <vector>
+ #include <arpa/nameser.h>
+diff --git a/methods/connect.cc b/methods/connect.cc
+index 1d6f891..122df35 100644
+--- a/methods/connect.cc
++++ b/methods/connect.cc
+@@ -42,6 +42,11 @@
+ #include "connect.h"
+ #include "rfc2553emu.h"
+ #include <apti18n.h>
++
++#ifndef AI_IDN
++#define AI_IDN 0x0040
++#endif
++
+ 									/*}}}*/
+ 
+ static std::string LastHost;
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-Include-array.h-for-std-array.patch b/poky/meta/recipes-devtools/apt/apt/0001-Include-array.h-for-std-array.patch
deleted file mode 100644
index e4a8faa..0000000
--- a/poky/meta/recipes-devtools/apt/apt/0001-Include-array.h-for-std-array.patch
+++ /dev/null
@@ -1,35 +0,0 @@
-From 4d64ec843185bf6fd1b85c3a6a4c4e3c968c8ab1 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Sun, 20 Jan 2019 18:56:58 -0800
-Subject: [PATCH] Include <array.h> for std::array
-
-When compiling using clang/libc++ it fails to build because this header
-is not included, with libstdc++ this seems to be pulled in
-automatically.
-
-Fixes below error
-
-apt-pkg/contrib/strutl.cc:949:38: error: implicit instantiation of undefined template 'std::__1::array<const char *const, 7>'
-   std::array<char const * const, 7> c_weekdays = {{ "sun", "mon", "tue", "wed", "thu", "fri", "sat" }};
-
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
-Upstream-Status: Backport [https://github.com/Debian/apt/commit/24a59c62efafbdb8387b2d3c5616b04b9fd21306]
----
- apt-pkg/contrib/strutl.cc | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
-index 60d0ca8..c2bfcbc 100644
---- a/apt-pkg/contrib/strutl.cc
-+++ b/apt-pkg/contrib/strutl.cc
-@@ -21,6 +21,7 @@
- #include <apt-pkg/fileutl.h>
- #include <apt-pkg/error.h>
- 
-+#include <array>
- #include <algorithm>
- #include <iomanip>
- #include <locale>
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-Revert-always-run-dpkg-configure-a-at-the-end-of-our.patch b/poky/meta/recipes-devtools/apt/apt/0001-Revert-always-run-dpkg-configure-a-at-the-end-of-our.patch
index 734ba00..8c4cc04 100644
--- a/poky/meta/recipes-devtools/apt/apt/0001-Revert-always-run-dpkg-configure-a-at-the-end-of-our.patch
+++ b/poky/meta/recipes-devtools/apt/apt/0001-Revert-always-run-dpkg-configure-a-at-the-end-of-our.patch
@@ -1,11 +1,9 @@
-From dfc1370d50322e2e9d225a7a63b44993fc01a727 Mon Sep 17 00:00:00 2001
-From: Roy Li <rongqing.li@windriver.com>
-Date: Fri, 22 May 2015 08:05:15 +0800
+From 742fbb243f99e940c3e6b31296f7f416f550a57a Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Thu, 21 May 2020 20:13:25 +0000
 Subject: [PATCH] Revert "always run 'dpkg --configure -a' at the end of our
  dpkg callings"
 
-Upstream-Status: Inappropriate [embedded specific]
-
 This reverts commit a2a75ff4516f7609f4c55b42270abb8d08943c60, which
 always run 'dpkg --configure -a' at the end of our dpkg callings,
 but it does not work for cross-compile, since the rootfs dir can not
@@ -14,19 +12,19 @@
    |mkdir: cannot create directory '/usr/lib/opkg': Permission denied
    -------
 
-Signed-off-by: Roy Li <rongqing.li@windriver.com>
+Upstream-Status: Inappropriate [embedded specific]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+
 ---
- apt-pkg/deb/dpkgpm.cc                                     |  9 ++-------
- test/integration/test-apt-progress-fd-deb822              | 14 +++++++-------
- test/integration/test-no-fds-leaked-to-maintainer-scripts |  6 ++----
- 3 files changed, 11 insertions(+), 18 deletions(-)
+ apt-pkg/deb/dpkgpm.cc | 9 ++-------
+ 1 file changed, 2 insertions(+), 7 deletions(-)
 
 diff --git a/apt-pkg/deb/dpkgpm.cc b/apt-pkg/deb/dpkgpm.cc
-index 533d9b367..6ce81bbd9 100644
+index ffa880d..5875e86 100644
 --- a/apt-pkg/deb/dpkgpm.cc
 +++ b/apt-pkg/deb/dpkgpm.cc
-@@ -1041,12 +1041,6 @@ void pkgDPkgPM::BuildPackagesProgressMap()
- 	 PackagesTotal++;
+@@ -1215,12 +1215,6 @@ void pkgDPkgPM::BuildPackagesProgressMap()
+ 	 }
        }
     }
 -   /* one extra: We don't want the progress bar to reach 100%, especially not
@@ -37,90 +35,14 @@
 -   ++PackagesTotal;
  }
                                                                          /*}}}*/
- bool pkgDPkgPM::Go(int StatusFd)
-@@ -1268,8 +1262,9 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
+ bool pkgDPkgPM::Go(int StatusFd)					/*{{{*/
+@@ -1716,7 +1710,8 @@ bool pkgDPkgPM::Go(APT::Progress::PackageManager *progress)
  
-    // support subpressing of triggers processing for special
-    // cases like d-i that runs the triggers handling manually
-+   bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all");
+       // support subpressing of triggers processing for special
+       // cases like d-i that runs the triggers handling manually
+-      if (_config->FindB("DPkg::ConfigurePending", true))
++      bool const SmartConf = (_config->Find("PackageManager::Configure", "all") != "all");
++      if (0)
+ 	 List.emplace_back(Item::ConfigurePending, pkgCache::PkgIterator());
+    }
     bool const TriggersPending = _config->FindB("DPkg::TriggersPending", false);
--   if (_config->FindB("DPkg::ConfigurePending", true) == true)
-+   if (_config->FindB("DPkg::ConfigurePending", SmartConf) == true)
-       List.push_back(Item(Item::ConfigurePending, PkgIterator()));
- 
-    // for the progress
-diff --git a/test/integration/test-apt-progress-fd-deb822 b/test/integration/test-apt-progress-fd-deb822
-index a8d59608d..0c6a9bbbf 100755
---- a/test/integration/test-apt-progress-fd-deb822
-+++ b/test/integration/test-apt-progress-fd-deb822
-@@ -27,36 +27,36 @@ Message: Installing testing (amd64)
- 
- Status: progress
- Package: testing:amd64
--Percent: 16.6667
-+Percent: 20
- Message: Preparing testing (amd64)
- 
- Status: progress
- Package: testing:amd64
--Percent: 33.3333
-+Percent: 40
- Message: Unpacking testing (amd64)
- 
- Status: progress
- Package: testing:amd64
--Percent: 50.0000
-+Percent: 60.0000
- Message: Preparing to configure testing (amd64)
- 
- Status: progress
--Percent: 50.0000
-+Percent: 60.0000
- Message: Running dpkg
- 
- Status: progress
- Package: testing:amd64
--Percent: 50.0000
-+Percent: 60.0000
- Message: Configuring testing (amd64)
- 
- Status: progress
- Package: testing:amd64
--Percent: 66.6667
-+Percent: 80
- Message: Configuring testing (amd64)
- 
- Status: progress
- Package: testing:amd64
--Percent: 83.3333
-+Percent: 100
- Message: Installed testing (amd64)
- 
- Status: progress
-diff --git a/test/integration/test-no-fds-leaked-to-maintainer-scripts b/test/integration/test-no-fds-leaked-to-maintainer-scripts
-index d86e638cd..ef6d23be2 100755
---- a/test/integration/test-no-fds-leaked-to-maintainer-scripts
-+++ b/test/integration/test-no-fds-leaked-to-maintainer-scripts
-@@ -59,8 +59,7 @@ startup packages configure
- configure $PKGNAME 1.0 <none>
- status unpacked $PKGNAME 1.0
- status half-configured $PKGNAME 1.0
--status installed $PKGNAME 1.0
--startup packages configure" cut -f 3- -d' ' rootdir/var/log/dpkg.log
-+status installed $PKGNAME 1.0" cut -f 3- -d' ' rootdir/var/log/dpkg.log
- }
- checkinstall
- 
-@@ -85,8 +84,7 @@ status config-files $PKGNAME 1.0
- status config-files $PKGNAME 1.0
- status config-files $PKGNAME 1.0
- status config-files $PKGNAME 1.0
--status not-installed $PKGNAME <none>
--startup packages configure" cut -f 3- -d' ' rootdir/var/log/dpkg.log
-+status not-installed $PKGNAME <none>" cut -f 3- -d' ' rootdir/var/log/dpkg.log
- }
- checkpurge
- 
--- 
-2.11.0
-
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-The-C.UTF-8-locale-is-not-portable-use-std-locale-cl.patch b/poky/meta/recipes-devtools/apt/apt/0001-The-C.UTF-8-locale-is-not-portable-use-std-locale-cl.patch
deleted file mode 100644
index ce5c005..0000000
--- a/poky/meta/recipes-devtools/apt/apt/0001-The-C.UTF-8-locale-is-not-portable-use-std-locale-cl.patch
+++ /dev/null
@@ -1,27 +0,0 @@
-From 7e8839731ae3fdf7502b91643aa6b252f6c5eaa6 Mon Sep 17 00:00:00 2001
-From: Adrian Bunk <bunk@stusta.de>
-Date: Thu, 14 May 2020 00:08:21 +0300
-Subject: The C.UTF-8 locale is not portable, use std::locale::classic()
-
-Upstream-Status: Inappropriate [Similar fix already in apt >= 1.3]
-Signed-off-by: Adrian Bunk <bunk@stusta.de>
----
- ftparchive/writer.cc | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/ftparchive/writer.cc b/ftparchive/writer.cc
-index 25963820a..6ad571d2a 100644
---- a/ftparchive/writer.cc
-+++ b/ftparchive/writer.cc
-@@ -984,7 +984,7 @@ ReleaseWriter::ReleaseWriter(FileFd * const GivenOutput, string const &/*DB*/) :
-    AddPatterns(_config->FindVector("APT::FTPArchive::Release::Patterns"));
- 
-    time_t const now = time(NULL);
--   auto const posix = std::locale("C.UTF-8");
-+   auto const posix = std::locale::classic();
- 
-    // FIXME: use TimeRFC1123 here? But that uses GMT to satisfy HTTP/1.1
-    std::ostringstream datestr;
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-apt-1.2.12-Fix-musl-build.patch b/poky/meta/recipes-devtools/apt/apt/0001-apt-1.2.12-Fix-musl-build.patch
deleted file mode 100644
index f7ac19b..0000000
--- a/poky/meta/recipes-devtools/apt/apt/0001-apt-1.2.12-Fix-musl-build.patch
+++ /dev/null
@@ -1,50 +0,0 @@
-From 33b97e089d4a98d3acd20bd78337dd915b989bc2 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?An=C3=ADbal=20Lim=C3=B3n?= <anibal.limon@linux.intel.com>
-Date: Fri, 5 Aug 2016 15:24:27 -0500
-Subject: [PATCH] apt 1.2.12: Fix musl build
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-methods/connect.cc: Musl doesn't support AI_IDN flag in netdb.h
-header so define it manually.
-apt-pkg/contrib/srvrec.h: Add explicity include of sys/types.h
-to avoid errors in types u_int_SIZE.
-
-Upstream-Status: Pending
-
-Signed-off-by: Aníbal Limón <anibal.limon@linux.intel.com>
----
- apt-pkg/contrib/srvrec.h | 1 +
- methods/connect.cc       | 3 +++
- 2 files changed, 4 insertions(+)
-
-diff --git a/apt-pkg/contrib/srvrec.h b/apt-pkg/contrib/srvrec.h
-index 01b8102..15b6875 100644
---- a/apt-pkg/contrib/srvrec.h
-+++ b/apt-pkg/contrib/srvrec.h
-@@ -9,6 +9,7 @@
- #ifndef SRVREC_H
- #define SRVREC_H
- 
-+#include <sys/types.h>
- #include <arpa/nameser.h>
- #include <vector>
- #include <string>
-diff --git a/methods/connect.cc b/methods/connect.cc
-index 07a730b..bb0ab5a 100644
---- a/methods/connect.cc
-+++ b/methods/connect.cc
-@@ -33,6 +33,9 @@
- #include <sys/socket.h>
- #include <arpa/inet.h>
- #include <netdb.h>
-+#ifndef AI_IDN
-+#define AI_IDN 0x0040
-+#endif
- 
- #include "connect.h"
- #include "rfc2553emu.h"
--- 
-2.1.4
-
diff --git a/poky/meta/recipes-devtools/apt/apt/0001-environment.mak-musl-based-systems-can-generate-shar.patch b/poky/meta/recipes-devtools/apt/apt/0001-environment.mak-musl-based-systems-can-generate-shar.patch
deleted file mode 100644
index 042372b..0000000
--- a/poky/meta/recipes-devtools/apt/apt/0001-environment.mak-musl-based-systems-can-generate-shar.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-From 2f8aa21ace375c18977ed908b291c80a210a93c6 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Thu, 31 Dec 2015 08:06:12 +0000
-Subject: [PATCH] environment.mak: musl based systems can generate shared
- objects too
-
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
-Upstream-Status: Pending
-
- buildlib/environment.mak.in | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/buildlib/environment.mak.in b/buildlib/environment.mak.in
-index b0a8d9d..3a52344 100644
---- a/buildlib/environment.mak.in
-+++ b/buildlib/environment.mak.in
-@@ -68,7 +68,7 @@ NEED_SOCKLEN_T_DEFINE = @NEED_SOCKLEN_T_DEFINE@
- 
- # Shared library things
- HOST_OS = @host_os@
--ifneq ($(words $(filter gnu% linux-gnu% kfreebsd-gnu% %-gnu,$(HOST_OS))),0)
-+ifneq ($(words $(filter gnu% linux-gnu% kfreebsd-gnu% %-gnu linux-musl%,$(HOST_OS))),0)
-    SONAME_MAGIC=-Wl,-soname -Wl,
-    LFLAGS_SO=
- else
--- 
-2.6.4
-
diff --git a/poky/meta/recipes-devtools/apt/apt/disable-configure-in-makefile.patch b/poky/meta/recipes-devtools/apt/apt/disable-configure-in-makefile.patch
deleted file mode 100644
index 7c2f64e..0000000
--- a/poky/meta/recipes-devtools/apt/apt/disable-configure-in-makefile.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-Disable configure at compilation stage
-
-Upstream-Status: Inappropriate [configuration]
-Signed-off-by: Constantin Musca <constantinx.musca@intel.com>
-
-Index: apt-0.9.7.7/Makefile
-===================================================================
---- apt-0.9.7.7.orig/Makefile
-+++ apt-0.9.7.7/Makefile
-@@ -33,7 +33,7 @@ veryclean: clean
- # The startup target builds the necessary configure scripts. It should
- # be used after a CVS checkout.
- CONVERTED=environment.mak include/config.h include/apti18n.h build/doc/Doxyfile makefile
--include buildlib/configure.mak
-+#include buildlib/configure.mak
- $(BUILDDIR)/include/config.h: buildlib/config.h.in
- $(BUILDDIR)/include/apti18n.h: buildlib/apti18n.h.in
- $(BUILDDIR)/environment.mak: buildlib/environment.mak.in
diff --git a/poky/meta/recipes-devtools/apt/apt/disable-test.patch b/poky/meta/recipes-devtools/apt/apt/disable-test.patch
deleted file mode 100644
index d16b5c7..0000000
--- a/poky/meta/recipes-devtools/apt/apt/disable-test.patch
+++ /dev/null
@@ -1,72 +0,0 @@
-From 67bc7948e0a721c75d636931abc105da5dcb0763 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?An=C3=ADbal=20Lim=C3=B3n?= <anibal.limon@linux.intel.com>
-Date: Thu, 26 May 2016 15:32:11 -0500
-Subject: [PATCH] [PATCH] disable test
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Upstream-Status: Inappropriate [configuration]
-
-test needs gtest package, so not build the test dir
-
-Signed-off-by: Roy Li <rongqing.li@windriver.com>
-Signed-off-by: Aníbal Limón <anibal.limon@linux.intel.com>
----
- Makefile     | 9 +++------
- configure.ac | 7 -------
- 2 files changed, 3 insertions(+), 13 deletions(-)
-
-Index: apt-1.2.24/Makefile
-===================================================================
---- apt-1.2.24.orig/Makefile
-+++ apt-1.2.24/Makefile
-@@ -9,8 +9,8 @@ endif
- .PHONY: default
- default: startup all
- 
--.PHONY: fast headers library clean veryclean all binary program doc test update-po
--all headers library clean veryclean binary program doc manpages docbook test update-po startup dirs:
-+.PHONY: fast headers library clean veryclean all binary program doc update-po
-+all headers library clean veryclean binary program doc manpages docbook update-po startup dirs:
- 	$(MAKE) -C vendor $@
- 	$(MAKE) -C apt-pkg $@
- 	$(MAKE) -C apt-inst $@
-@@ -21,8 +21,6 @@ all headers library clean veryclean bina
- 	$(MAKE) -C dselect $@
- #	$(MAKE) -C doc $@
- 	$(MAKE) -C po $@
--	# FIXME: -C test has issue swith parallel builds, investigate!
--	-$(MAKE) -C test $@
- 
- fast:
- 	$(MAKE) -C vendor all
-@@ -32,9 +30,8 @@ fast:
- 	$(MAKE) -C methods all
- 	$(MAKE) -C cmdline all
- 	$(MAKE) -C ftparchive all
--	$(MAKE) -C test all
- 
--all headers library clean veryclean binary program doc manpages docbook test update-po: startup dirs
-+all headers library clean veryclean binary program doc manpages docbook update-po: startup dirs
- 
- dirs: startup
- 
-Index: apt-1.2.24/configure.ac
-===================================================================
---- apt-1.2.24.orig/configure.ac
-+++ apt-1.2.24/configure.ac
-@@ -90,13 +90,6 @@ AC_CHECK_LIB(curl, curl_easy_init,
-      AC_MSG_ERROR([failed: I need CURL due https support]),
- )
- 
--AC_LANG_PUSH([C++])
--AC_CHECK_HEADER(gtest/gtest.h,,
--     AC_MSG_WARN([failed: I need gtest (packaged as libgtest-dev) for unit testing]),
--)
--AC_LANG_POP([C++])
--
--
- AC_SUBST(BDBLIB)
- 
- HAVE_ZLIB=no
diff --git a/poky/meta/recipes-devtools/apt/apt/fix-gcc-4.6-null-not-defined.patch b/poky/meta/recipes-devtools/apt/apt/fix-gcc-4.6-null-not-defined.patch
deleted file mode 100644
index 899c6ef..0000000
--- a/poky/meta/recipes-devtools/apt/apt/fix-gcc-4.6-null-not-defined.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-Upstream-Status: Pending
-
-Index: apt-1.2.24/apt-pkg/contrib/weakptr.h
-===================================================================
---- apt-1.2.24.orig/apt-pkg/contrib/weakptr.h
-+++ apt-1.2.24/apt-pkg/contrib/weakptr.h
-@@ -21,6 +21,7 @@
- #ifndef WEAK_POINTER_H
- #define WEAK_POINTER_H
- 
-+#include <cstdlib>
- #include <set>
- #include <stddef.h>
- 
diff --git a/poky/meta/recipes-devtools/apt/apt/makerace.patch b/poky/meta/recipes-devtools/apt/apt/makerace.patch
deleted file mode 100644
index 0c686d6..0000000
--- a/poky/meta/recipes-devtools/apt/apt/makerace.patch
+++ /dev/null
@@ -1,23 +0,0 @@
-I was seeing various issues with parallel make, mainly due to to what was likely 
-partially installed headers. If you change into the source directory and
-"NOISY=1 make  ../obj/apt-pkg/sourcelist.opic" in apt-pkg, you'll see it 
-doesn't have any dependencies on the headers being installed. This patch
-fixes that so things build correctly.
-
-RP 2012/3/19
-
-Upstream-Status: Pending
-
-Index: apt-1.2.24/buildlib/library.mak
-===================================================================
---- apt-1.2.24.orig/buildlib/library.mak
-+++ apt-1.2.24/buildlib/library.mak
-@@ -65,7 +65,7 @@ $(LIB)/lib$(LIBRARY).so.$(MAJOR).$(MINOR
- 
- # Compilation rules
- vpath %.cc $(SUBDIRS)
--$(OBJ)/%.opic: %.cc $(LIBRARYDEPENDS)
-+$(OBJ)/%.opic: %.cc $(LIBRARYDEPENDS) $($(LOCAL)-HEADERS)
- 	echo Compiling $< to $@
- 	$(CXX) -c $(INLINEDEPFLAG) $(CPPFLAGS) $(CXXSTD) $(CXXFLAGS) $(PICFLAGS) -o $@ '$(abspath $<)'
- 	$(DoDep)
diff --git a/poky/meta/recipes-devtools/apt/apt/no-nls-dpkg.patch b/poky/meta/recipes-devtools/apt/apt/no-nls-dpkg.patch
deleted file mode 100644
index 98b6c96..0000000
--- a/poky/meta/recipes-devtools/apt/apt/no-nls-dpkg.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-Upstream-Status: Pending
-
-Index: apt-1.2.24/apt-pkg/deb/dpkgpm.cc
-===================================================================
---- apt-1.2.24.orig/apt-pkg/deb/dpkgpm.cc
-+++ apt-1.2.24/apt-pkg/deb/dpkgpm.cc
-@@ -54,6 +54,12 @@
- #include <apti18n.h>
- 									/*}}}*/
- 
-+#ifdef USE_NLS
-+#define _dpkg(x) dgettext("dpkg", x)
-+#else
-+#define _dpkg(x) x
-+#endif
-+
- using namespace std;
- 
- APT_PURE static string
-@@ -1703,7 +1709,7 @@ void pkgDPkgPM::WriteApportReport(const
-    }
- 
-    // check if its not a follow up error 
--   const char *needle = dgettext("dpkg", "dependency problems - leaving unconfigured");
-+   const char *needle = _dpkg("dependency problems - leaving unconfigured");
-    if(strstr(errormsg, needle) != NULL) {
-       std::clog << _("No apport report written because the error message indicates its a followup error from a previous failure.") << std::endl;
-       return;
diff --git a/poky/meta/recipes-devtools/apt/apt/noconfigure.patch b/poky/meta/recipes-devtools/apt/apt/noconfigure.patch
deleted file mode 100644
index ebc6720..0000000
--- a/poky/meta/recipes-devtools/apt/apt/noconfigure.patch
+++ /dev/null
@@ -1,37 +0,0 @@
-Upstream-Status: Inappropriate [configuration]
-Signed-off-by: Constantin Musca <constantinx.musca@intel.com>
-
-
-diff --git a/apt-pkg/packagemanager.cc b/apt-pkg/packagemanager.cc
-index 249542c..0a1911f 100644
---- a/apt-pkg/packagemanager.cc
-+++ b/apt-pkg/packagemanager.cc
-@@ -952,10 +952,12 @@ bool pkgPackageManager::SmartUnPack(PkgIterator Pkg, bool const Immediate, int c
-       return false;
- 
-    if (Immediate == true) {
-+#if 0
-       // Perform immedate configuration of the package. 
-          if (SmartConfigure(Pkg, Depth + 1) == false)
-             _error->Error(_("Could not perform immediate configuration on '%s'. "
-                "Please see man 5 apt.conf under APT::Immediate-Configure for details. (%d)"),Pkg.FullName().c_str(),2);
-+#endif
-    }
-    
-    return true;
-@@ -1038,6 +1040,7 @@ pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
-       }
-    }
- 
-+#if 0
-    // Final run through the configure phase
-    if (ConfigureAll() == false)
-       return Failed;
-@@ -1052,6 +1055,7 @@ pkgPackageManager::OrderResult pkgPackageManager::OrderInstall()
- 	 return Failed;
-       }
-    }
-+#endif
- 	 
-    return Completed;
- }
diff --git a/poky/meta/recipes-devtools/apt/apt/nodoc.patch b/poky/meta/recipes-devtools/apt/apt/nodoc.patch
deleted file mode 100644
index 78cf538..0000000
--- a/poky/meta/recipes-devtools/apt/apt/nodoc.patch
+++ /dev/null
@@ -1,18 +0,0 @@
-Disable documentation
-
-Upstream-Status: Inappropriate [configuration]
-Signed-off-by: Constantin Musca <constantinx.musca@intel.com>
-
-Index: apt-1.2.24/Makefile
-===================================================================
---- apt-1.2.24.orig/Makefile
-+++ apt-1.2.24/Makefile
-@@ -19,7 +19,7 @@ all headers library clean veryclean bina
- 	$(MAKE) -C cmdline $@
- 	$(MAKE) -C ftparchive $@
- 	$(MAKE) -C dselect $@
--	$(MAKE) -C doc $@
-+#	$(MAKE) -C doc $@
- 	$(MAKE) -C po $@
- 	# FIXME: -C test has issue swith parallel builds, investigate!
- 	-$(MAKE) -C test $@
diff --git a/poky/meta/recipes-devtools/apt/apt/triehash b/poky/meta/recipes-devtools/apt/apt/triehash
new file mode 100755
index 0000000..b08bc6e
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt/triehash
@@ -0,0 +1,728 @@
+#!/usr/bin/perl -w
+#
+# Copyright (C) 2016 Julian Andres Klode <jak@jak-linux.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+=encoding utf8
+
+=head1 NAME
+
+triehash - Generate a perfect hash function derived from a trie.
+
+=cut
+
+use strict;
+use warnings;
+use utf8;
+use Getopt::Long;
+
+=head1 SYNOPSIS
+
+B<triehash> [S<I<option>>] [S<I<input file>>]
+
+=head1 DESCRIPTION
+
+triehash takes a list of words in input file and generates a function and
+an enumeration to describe the word
+
+=head1 INPUT FILE FORMAT
+
+The file consists of multiple lines of the form:
+
+    [label ~ ] word [= value]
+
+This maps word to value, and generates an enumeration with entries of the form:
+
+    label = value
+
+If I<label> is undefined, the word will be used, the minus character will be
+replaced by an underscore. If value is undefined it is counted upwards from
+the last value.
+
+There may also be one line of the format
+
+    [ label ~] = value
+
+Which defines the value to be used for non-existing keys. Note that this also
+changes default value for other keys, as for normal entries. So if you place
+
+    = 0
+
+at the beginning of the file, unknown strings map to 0, and the other strings
+map to values starting with 1. If label is not specified, the default is
+I<Unknown>.
+
+=head1 OPTIONS
+
+=over 4
+
+=item B<-C>I<.c file> B<--code>=I<.c file>
+
+Generate code in the given file.
+
+=item B<-H>I<header file> B<--header>=I<header file>
+
+Generate a header in the given file, containing a declaration of the hash
+function and an enumeration.
+
+=item B<--enum-name=>I<word>
+
+The name of the enumeration.
+
+=item B<--function-name=>I<word>
+
+The name of the function.
+
+=item B<--label-prefix=>I<word>
+
+The prefix to use for labels.
+
+=item B<--label-uppercase>
+
+Uppercase label names when normalizing them.
+
+=item B<--namespace=>I<name>
+
+Put the function and enum into a namespace (C++)
+
+=item B<--class=>I<name>
+
+Put the function and enum into a class (C++)
+
+=item B<--enum-class>
+
+Generate an enum class instead of an enum (C++)
+
+=item B<--counter-name=>I<name>
+
+Use I<name> for a counter that is set to the latest entry in the enumeration
++ 1. This can be useful for defining array sizes.
+
+=item B<--ignore-case>
+
+Ignore case for words.
+
+=item B<--multi-byte>=I<value>
+
+Generate code reading multiple bytes at once. The value is a string of power
+of twos to enable. The default value is 320 meaning that 8, 4, and single byte
+reads are enabled. Specify 0 to disable multi-byte completely, or add 2 if you
+also want to allow 2-byte reads. 2-byte reads are disabled by default because
+they negatively affect performance on older Intel architectures.
+
+This generates code for both multiple bytes and single byte reads, but only
+enables the multiple byte reads of GNU C compatible compilers, as the following
+extensions are used:
+
+=over 8
+
+=item Byte-aligned integers
+
+We must be able to generate integers that are aligned to a single byte using:
+
+    typedef uint64_t __attribute__((aligned (1))) triehash_uu64;
+
+=item Byte-order
+
+The macros __BYTE_ORDER__ and __ORDER_LITTLE_ENDIAN__ must be defined.
+
+=back
+
+We forcefully disable multi-byte reads on platforms where the variable
+I<__ARM_ARCH> is defined and I<__ARM_FEATURE_UNALIGNED> is not defined,
+as there is a measurable overhead from emulating the unaligned reads on
+ARM.
+
+=item B<--language=>I<language>
+
+Generate a file in the specified language. Currently known are 'C' and 'tree',
+the latter generating a tree.
+
+=item B<--include=>I<header>
+
+Add the header to the include statements of the header file. The value must
+be surrounded by quotes or angle brackets for C code. May be specified multiple
+times.
+
+=back
+
+=cut
+
+my $unknown = -1;
+my $unknown_label = undef;
+my $counter_start = 0;
+my $enum_name = 'PerfectKey';
+my $function_name = 'PerfectHash';
+my $enum_class = 0;
+
+my $code_name = '-';
+my $header_name = '-';
+my $code;
+my $header;
+my $label_prefix = undef;
+my $label_uppercase = 0;
+my $ignore_case = 0;
+my $multi_byte = '320';
+my $language = 'C';
+my $counter_name = undef;
+my @includes = ();
+
+
+Getopt::Long::config('default',
+                     'bundling',
+                     'no_getopt_compat',
+                     'no_auto_abbrev',
+                     'permute',
+                     'auto_help');
+
+GetOptions ('code|C=s' => \$code_name,
+            'header|H=s'   => \$header_name,
+            'function-name=s' => \$function_name,
+            'label-prefix=s' => \$label_prefix,
+            'label-uppercase' => \$label_uppercase,
+            'ignore-case' => \$ignore_case,
+            'enum-name=s' => \$enum_name,
+            'language|l=s' => \$language,
+            'multi-byte=s' => \$multi_byte,
+            'enum-class' => \$enum_class,
+            'include=s' => \@includes,
+            'counter-name=s' => \$counter_name)
+    or die('Could not parse options!');
+
+
+# This implements a simple trie. Each node has three attributes:
+#
+# children - A hash of keys to other nodes
+# value    - The value to be stored here
+# label    - A named representation of the value.
+#
+# The key at each level of the trie can consist of one or more bytes, and the
+# trie can be normalized to a form where all keys at a level have the same
+# length using rebuild_tree().
+package Trie {
+
+    sub new {
+        my $class = shift;
+        my $self = {};
+        bless $self, $class;
+
+        $self->{children} = {};
+        $self->{value} = undef;
+        $self->{label} = undef;
+
+        return $self;
+    }
+
+    # Return the largest power of 2 smaller or equal to the argument
+    sub alignpower2 {
+        my ($self, $length) = @_;
+
+        return 8 if ($length >= 8 && $multi_byte =~ /3/);
+        return 4 if ($length >= 4 && $multi_byte =~ /2/);
+        return 2 if ($length >= 2 && $multi_byte =~ /1/);
+
+        return 1;
+    }
+
+    # Split the key into a head block and a tail
+    sub split_key {
+        my ($self, $key) = @_;
+        my $length = length $key;
+        my $split = $self->alignpower2($length);
+
+        return (substr($key, 0, $split), substr($key, $split));
+    }
+
+    # Given a key, a label, and a value, insert that into the tree, possibly
+    # replacing an existing node.
+    sub insert {
+        my ($self, $key, $label, $value) = @_;
+
+        if (length($key) == 0) {
+            $self->{label} = $label;
+            $self->{value} = $value;
+            return;
+        }
+
+        my ($child, $tail) = $self->split_key($key);
+
+        $self->{children}{$child} = Trie->new if (!defined($self->{children}{$child}));
+
+        $self->{children}{$child}->insert($tail, $label, $value);
+    }
+
+    # Construct a new trie that only contains words of a given length. This
+    # is used to split up the common trie after knowing all words, so we can
+    # switch on the expected word length first, and have the per-trie function
+    # implement simple longest prefix matching.
+    sub filter_depth {
+        my ($self, $togo) = @_;
+
+        my $new = Trie->new;
+
+        if ($togo != 0) {
+            my $found = 0;
+            foreach my $key (sort keys %{$self->{children}}) {
+                if ($togo > length($key) || defined $self->{children}{$key}->{value}) {
+                    my $child = $self->{children}{$key}->filter_depth($togo - length($key));
+
+                    $new->{children}{$key}= $child if defined $child;
+                    $found = 1 if defined $child;
+                }
+            }
+            return if (!$found);
+        } else {
+            $new->{value} = $self->{value};
+            $new->{label} = $self->{label};
+        }
+
+        return $new;
+    }
+
+    # (helper for rebuild_tree)
+    # Reinsert all value nodes into the specified $trie, prepending $prefix
+    # to their $paths.
+    sub reinsert_value_nodes_into {
+        my ($self, $trie, $prefix) = @_;
+
+        $trie->insert($prefix, $self->{label}, $self->{value}) if (defined $self->{value});
+
+        foreach my $key (sort keys %{$self->{children}}) {
+            $self->{children}{$key}->reinsert_value_nodes_into($trie, $prefix . $key);
+        }
+    }
+
+    # (helper for rebuild_tree)
+    # Find the earliest point to split a key. Normally, we split at the maximum
+    # power of 2 that is greater or equal than the length of the key. When we
+    # are building an ASCII-optimised case-insensitive trie that simply ORs
+    # each byte with 0x20, we need to split at the first ambiguous character:
+    #
+    # For example, the words a-bc and a\rbc are identical in such a situation:
+    #       '-' | 0x20 == '-' == '\r' | 0x20
+    # We cannot simply switch on all 4 bytes at once, but need to split before
+    # the ambiguous character so we can process the ambiguous character on its
+    # own.
+    sub find_earlier_split {
+        my ($self, $key) = @_;
+
+        if ($ignore_case) {
+            for my $i (0..length($key)-1) {
+                # If the key starts with an ambiguous character, we need to
+                # take only it. Otherwise, we need to take everything
+                # before the character.
+                return $self->alignpower2($i || 1) if (main::ambiguous(substr($key, $i, 1)));
+            }
+        }
+        return $self->alignpower2(length $key);
+    }
+
+    # This rebuilds the trie, splitting each key before ambiguous characters
+    # as explained in find_earlier_split(), and then chooses the smallest
+    # such split at each level, so that all keys at all levels have the same
+    # length (so we can use a multi-byte switch).
+    sub rebuild_tree {
+        my $self = shift;
+        # Determine if/where we need to split before an ambiguous character
+        my $new_split = 99999999999999999;
+        foreach my $key (sort keys %{$self->{children}}) {
+            my $special_length = $self->find_earlier_split($key);
+            $new_split = $special_length if ($special_length < $new_split);
+        }
+
+        # Start building a new uniform trie
+        my $newself = Trie->new;
+        $newself->{label} = $self->{label};
+        $newself->{value} = $self->{value};
+        $newself->{children} = {};
+
+        foreach my $key (sort keys %{$self->{children}}) {
+            my $head = substr($key, 0, $new_split);
+            my $tail = substr($key, $new_split);
+            # Rebuild the child node at $head, pushing $tail downwards
+            $newself->{children}{$head} //= Trie->new;
+            $self->{children}{$key}->reinsert_value_nodes_into($newself->{children}{$head}, $tail);
+            # We took up to one special character of each key label. There might
+            # be more, so we need to rebuild recursively.
+            $newself->{children}{$head} = $newself->{children}{$head}->rebuild_tree();
+        }
+
+        return $newself;
+    }
+}
+
+# Code generator for C and C++
+package CCodeGen {
+    my $static = ($code_name eq $header_name) ? "static " : "";
+    my $enum_specifier = $enum_class ? "enum class" : "enum";
+
+    sub new {
+        my $class = shift;
+        my $self = {};
+        bless $self, $class;
+
+        return $self;
+    }
+
+    sub open_output {
+        my $self = shift;
+        if ($code_name ne '-') {
+            open($code, '>', $code_name) or die "Cannot open $code_name: $!" ;
+        } else {
+            $code = *STDOUT;
+        }
+        if($code_name eq $header_name) {
+            $header = $code;
+        } elsif ($header_name ne '-') {
+            open($header, '>', $header_name) or die "Cannot open $header_name: $!" ;
+        } else {
+            $header = *STDOUT;
+        }
+    }
+
+    sub mangle_label {
+        my ($self, $label) = @_;
+
+        $label = $label_prefix . $label if defined($label_prefix);
+        $label = uc $label if $label_uppercase;
+
+        return $label;
+    }
+
+    sub word_to_label {
+        my ($self, $word) = @_;
+
+        $word =~ s/_/__/g;
+        $word =~ s/-/_/g;
+
+        return $self->mangle_label($word);
+    }
+
+    # Return a case label, by shifting and or-ing bytes in the word
+    sub case_label {
+        my ($self, $key) = @_;
+
+        return sprintf("'%s'", substr($key, 0, 1)) if not $multi_byte;
+
+        my $output = '0';
+
+        for my $i (0..length($key)-1) {
+            $output .= sprintf("| onechar('%s', %d, %d)", substr($key, $i, 1), 8 * $i, 8*length($key));
+        }
+
+        return $output;
+    }
+
+    # Return an appropriate read instruction for $length bytes from $offset
+    sub switch_key {
+        my ($self, $offset, $length) = @_;
+
+        return "string[$offset]" if $length == 1;
+        return sprintf("*((triehash_uu%s*) &string[$offset])", $length * 8);
+    }
+
+    # Render the trie so that it matches the longest prefix.
+    sub print_table {
+        my ($self, $trie, $fh, $indent, $index) = @_;
+        $indent //= 0;
+        $index //= 0;
+
+        # If we have children, try to match them.
+        if (%{$trie->{children}}) {
+            # The difference between lowercase and uppercase alphabetical characters
+            # is that they have one bit flipped. If we have alphabetical characters
+            # in the search space, and the entire search space works fine if we
+            # always turn on the flip, just OR the character we are switching over
+            # with the bit.
+            my $want_use_bit = 0;
+            my $can_use_bit = 1;
+            my $key_length = 0;
+            foreach my $key (sort keys %{$trie->{children}}) {
+                $can_use_bit &= not main::ambiguous($key);
+                $want_use_bit |= ($key =~ /^[a-zA-Z]+$/);
+                $key_length = length($key);
+            }
+
+            if ($ignore_case && $can_use_bit && $want_use_bit) {
+                printf { $fh } (('    ' x $indent) . "switch(%s | 0x%s) {\n", $self->switch_key($index, $key_length), '20' x $key_length);
+            } else {
+                printf { $fh } (('    ' x $indent) . "switch(%s) {\n", $self->switch_key($index, $key_length));
+            }
+
+            my $notfirst = 0;
+            foreach my $key (sort keys %{$trie->{children}}) {
+                if ($notfirst) {
+                    printf { $fh } ('    ' x $indent . "    break;\n");
+                }
+                if ($ignore_case) {
+                    printf { $fh } ('    ' x $indent . "case %s:\n", $self->case_label(lc($key)));
+                    printf { $fh } ('    ' x $indent . "case %s:\n", $self->case_label(uc($key))) if lc($key) ne uc($key) && !($can_use_bit && $want_use_bit);
+                } else {
+                    printf { $fh } ('    ' x $indent . "case %s:\n", $self->case_label($key));
+                }
+
+                $self->print_table($trie->{children}{$key}, $fh, $indent + 1, $index + length($key));
+
+                $notfirst=1;
+            }
+
+            printf { $fh } ('    ' x $indent . "}\n");
+        }
+
+
+        # This node has a value, so it is a possible end point. If no children
+        # matched, we have found our longest prefix.
+        if (defined $trie->{value}) {
+            printf { $fh } ('    ' x $indent . "return %s;\n", ($enum_class ? "${enum_name}::" : '').$trie->{label});
+        }
+
+    }
+
+    sub print_words {
+        my ($self, $trie, $fh, $indent, $sofar) = @_;
+
+        $indent //= 0;
+        $sofar //= '';
+
+
+        printf { $fh } ('    ' x $indent."%s = %s,\n", $trie->{label}, $trie->{value}) if defined $trie->{value};
+
+        foreach my $key (sort keys %{$trie->{children}}) {
+            $self->print_words($trie->{children}{$key}, $fh, $indent, $sofar . $key);
+        }
+    }
+
+    sub print_functions {
+        my ($self, $trie, %lengths) = @_;
+        foreach my $local_length (sort { $a <=> $b } (keys %lengths)) {
+            print { $code } ("static enum ${enum_name} ${function_name}${local_length}(const char *string)\n");
+            print { $code } ("{\n");
+            $self->print_table($trie->filter_depth($local_length)->rebuild_tree(), $code, 1);
+            printf { $code } ("    return %s$unknown_label;\n", ($enum_class ? "${enum_name}::" : ''));
+            print { $code } ("}\n");
+        }
+    }
+
+    sub main {
+        my ($self, $trie, $num_values, %lengths) = @_;
+        print { $header } ("#ifndef TRIE_HASH_${function_name}\n");
+        print { $header } ("#define TRIE_HASH_${function_name}\n");
+        print { $header } ("#include <stddef.h>\n");
+        print { $header } ("#include <stdint.h>\n");
+        foreach my $include (@includes) {
+            print { $header } ("#include $include\n");
+        }
+        printf { $header } ("enum { $counter_name = $num_values };\n") if (defined($counter_name));
+        print { $header } ("${enum_specifier} ${enum_name} {\n");
+        $self->print_words($trie, $header, 1);
+        printf { $header } ("    $unknown_label = $unknown,\n");
+        print { $header } ("};\n");
+        print { $header } ("${static}enum ${enum_name} ${function_name}(const char *string, size_t length);\n");
+
+        print { $code } ("#include \"$header_name\"\n") if ($header_name ne $code_name);
+
+        if ($multi_byte) {
+            print { $code } ("#ifdef __GNUC__\n");
+            foreach my $i ((16, 32, 64)) {
+                print { $code } ("typedef uint${i}_t __attribute__((aligned (1))) triehash_uu${i};\n");
+                print { $code } ("typedef char static_assert${i}[__alignof__(triehash_uu${i}) == 1 ? 1 : -1];\n");
+            }
+
+            print { $code } ("#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__\n");
+            print { $code } ("#define onechar(c, s, l) (((uint64_t)(c)) << (s))\n");
+            print { $code } ("#else\n");
+            print { $code } ("#define onechar(c, s, l) (((uint64_t)(c)) << (l-8-s))\n");
+            print { $code } ("#endif\n");
+            print { $code } ("#if (!defined(__ARM_ARCH) || defined(__ARM_FEATURE_UNALIGNED)) && !defined(TRIE_HASH_NO_MULTI_BYTE)\n");
+            print { $code } ("#define TRIE_HASH_MULTI_BYTE\n");
+            print { $code } ("#endif\n");
+            print { $code } ("#endif /*GNUC */\n");
+
+            print { $code } ("#ifdef TRIE_HASH_MULTI_BYTE\n");
+            $self->print_functions($trie, %lengths);
+            $multi_byte = 0;
+            print { $code } ("#else\n");
+            $self->print_functions($trie, %lengths);
+            print { $code } ("#endif /* TRIE_HASH_MULTI_BYTE */\n");
+        } else {
+            $self->print_functions($trie, %lengths);
+        }
+
+        print { $code } ("${static}enum ${enum_name} ${function_name}(const char *string, size_t length)\n");
+        print { $code } ("{\n");
+        print { $code } ("    switch (length) {\n");
+        foreach my $local_length (sort { $a <=> $b } (keys %lengths)) {
+            print { $code } ("    case $local_length:\n");
+            print { $code } ("        return ${function_name}${local_length}(string);\n");
+        }
+        print { $code } ("    default:\n");
+        printf { $code } ("        return %s$unknown_label;\n", ($enum_class ? "${enum_name}::" : ''));
+        print { $code } ("    }\n");
+        print { $code } ("}\n");
+
+        # Print end of header here, in case header and code point to the same file
+        print { $header } ("#endif                       /* TRIE_HASH_${function_name} */\n");
+    }
+}
+
+# A character is ambiguous if the 1<<5 (0x20) bit does not correspond to the
+# lower case bit. A word is ambiguous if any character is. This definition is
+# used to check if we can perform the |0x20 optimization when building a case-
+# insensitive trie.
+sub ambiguous {
+    my $word = shift;
+
+    foreach my $char (split //, $word) {
+        # If 0x20 does not solely indicate lowercase, it is ambiguous
+        return 1 if ord(lc($char)) != (ord($char) | 0x20);
+        return 1 if ord(uc($char)) != (ord($char) & ~0x20);
+    }
+
+    return 0;
+}
+
+sub build_trie {
+    my $codegen = shift;
+    my $trie = Trie->new;
+
+    my $counter = $counter_start;
+    my $prev_value;
+    my %lengths;
+
+    open(my $input, '<', $ARGV[0]) or die "Cannot open $ARGV[0]: $!";
+    while (my $line = <$input>) {
+        my ($label, $word, $value) = $line =~ m{
+            (?:\s*([^~\s]+)\s*~)?      # Label ~
+            (?:\s*([^~=\s]+))?         # Word
+            (?:\s*=\s*([^\s]+)\s+)?    # = Value
+            \s*
+        }x;
+
+        if (defined $word) {
+            $label //= $codegen->word_to_label($word);
+            $value //= defined $prev_value ? $prev_value + 1 : 0;
+
+            $trie->insert($word, $label, $value);
+            $lengths{length($word)} = 1;
+        } elsif (defined $value) {
+            $unknown = $value;
+            $unknown_label = $codegen->mangle_label($label) if defined $label;
+        } else {
+            die "Invalid line: $line";
+        }
+
+        $prev_value = $value;
+        $counter = $value + 1 if $value >= $counter;
+    }
+
+    $unknown_label //= $codegen->mangle_label('Unknown');
+
+    return ($trie, $counter, %lengths);
+}
+
+# Generates an ASCII art tree
+package TreeCodeGen {
+
+    sub new {
+        my $class = shift;
+        my $self = {};
+        bless $self, $class;
+
+        return $self;
+    }
+
+    sub mangle_label {
+        my ($self, $label) = @_;
+        return $label;
+    }
+
+    sub word_to_label {
+        my ($self, $word) = @_;
+        return $word;
+    }
+
+    sub main {
+        my ($self, $trie, $counter, %lengths) = @_;
+        printf { $code } ("┌────────────────────────────────────────────────────┐\n");
+        printf { $code } ("│                   Initial trie                     │\n");
+        printf { $code } ("└────────────────────────────────────────────────────┘\n");
+        $self->print($trie);
+        printf { $code } ("┌────────────────────────────────────────────────────┐\n");
+        printf { $code } ("│                   Rebuilt trie                     │\n");
+        printf { $code } ("└────────────────────────────────────────────────────┘\n");
+        $self->print($trie->rebuild_tree());
+
+        foreach my $local_length (sort { $a <=> $b } (keys %lengths)) {
+            printf { $code } ("┌────────────────────────────────────────────────────┐\n");
+            printf { $code } ("│              Trie for words of length %-4d         │\n", $local_length);
+            printf { $code } ("└────────────────────────────────────────────────────┘\n");
+            $self->print($trie->filter_depth($local_length)->rebuild_tree());
+        }
+    }
+
+    sub open_output {
+        my $self = shift;
+        if ($code_name ne '-') {
+            open($code, '>:encoding(utf8)', $code_name) or die "Cannot open $ARGV[0]: $!" ;
+        } else {
+            $code = *STDOUT;
+            binmode($code, ':encoding(utf8)');
+        }
+    }
+
+    # Print a trie
+    sub print {
+        my ($self, $trie, $depth) = @_;
+        $depth //= 0;
+
+        print { $code } (' → ') if defined($trie->{label});
+        print { $code } ($trie->{label} // '', "\n");
+        foreach my $key (sort keys %{$trie->{children}}) {
+            print { $code } ('│   ' x ($depth), "├── $key");
+            $self->print($trie->{children}{$key}, $depth + 1);
+        }
+    }
+}
+
+my %codegens = (
+    C => 'CCodeGen',
+    tree => 'TreeCodeGen',
+);
+
+
+defined($codegens{$language}) or die "Unknown language $language. Valid choices: ", join(', ', keys %codegens);
+my $codegen = $codegens{$language}->new();
+my ($trie, $counter, %lengths) = build_trie($codegen);
+
+$codegen->open_output();
+$codegen->main($trie, $counter, %lengths);
+
+
+=head1 LICENSE
+
+triehash is available under the MIT/Expat license, see the source code
+for more information.
+
+=head1 AUTHOR
+
+Julian Andres Klode <jak@jak-linux.org>
+
+=cut
+
diff --git a/poky/meta/recipes-devtools/apt/apt/truncate-filename.patch b/poky/meta/recipes-devtools/apt/apt/truncate-filename.patch
deleted file mode 100644
index db1c42b..0000000
--- a/poky/meta/recipes-devtools/apt/apt/truncate-filename.patch
+++ /dev/null
@@ -1,35 +0,0 @@
-strutl.cc: the filename can't be longer than 255
-
-The URItoFileName translates the path into the filename, but the
-filename can't be longer than 255 according to
-/usr/include/linux/limits.h.
-
-Truncate it when it is longer than 240 (leave some spaces for
-".Packages" and "._Release" suffix)
-
-Upstream-Status: Pending
-Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
----
- apt-pkg/contrib/strutl.cc |    7 ++++++-
- 1 file changed, 6 insertions(+), 1 deletion(-)
-
-diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
---- a/apt-pkg/contrib/strutl.cc
-+++ b/apt-pkg/contrib/strutl.cc
-@@ -399,7 +399,12 @@ string URItoFileName(const string &URI)
-    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
-    string NewURI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
-    replace(NewURI.begin(),NewURI.end(),'/','_');
--   return NewURI;
-+
-+   // Truncate from the head when it is longer than 240
-+   if(NewURI.length() > 240)
-+       return NewURI.substr(NewURI.length() - 240, NewURI.length() - 1);
-+   else
-+       return NewURI;
- }
- 									/*}}}*/
- // Base64Encode - Base64 Encoding routine for short strings		/*{{{*/
--- 
-1.7.10.4
-
diff --git a/poky/meta/recipes-devtools/apt/apt/use-host.patch b/poky/meta/recipes-devtools/apt/apt/use-host.patch
deleted file mode 100644
index b30fcff..0000000
--- a/poky/meta/recipes-devtools/apt/apt/use-host.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-Upstream-Status: Pending
-
-Index: apt-0.9.7.7/configure.ac
-===================================================================
---- apt-0.9.7.7.orig/configure.ac
-+++ apt-0.9.7.7/configure.ac
-@@ -112,7 +112,7 @@ dnl This is often the dpkg architecture
- dnl First check against the full canonical canoncial-system-type in $target
- dnl and if that fails, just look for the cpu
- AC_MSG_CHECKING(debian architecture)
--archset="`dpkg-architecture -qDEB_HOST_ARCH`"
-+archset="`echo $host_alias|cut -d'-' -f1`"
- if test "x$archset" = "x"; then
-    AC_MSG_ERROR([failed: use --host= or output from dpkg-architecture])
- fi
diff --git a/poky/meta/recipes-devtools/apt/apt_1.2.31.bb b/poky/meta/recipes-devtools/apt/apt_1.2.31.bb
deleted file mode 100644
index ae0bce9..0000000
--- a/poky/meta/recipes-devtools/apt/apt_1.2.31.bb
+++ /dev/null
@@ -1,20 +0,0 @@
-DEPENDS = "curl db zlib"
-RDEPENDS_${PN} = "dpkg bash debianutils"
-require apt.inc
-
-require apt-package.inc
-
-PACKAGECONFIG ??= "lzma"
-PACKAGECONFIG[lzma] = "ac_cv_lib_lzma_lzma_easy_encoder=yes,ac_cv_lib_lzma_lzma_easy_encoder=no,xz"
-PACKAGECONFIG[bz2] = "ac_cv_lib_bz2_BZ2_bzopen=yes,ac_cv_lib_bz2_BZ2_bzopen=no,bzip2"
-PACKAGECONFIG[lz4] = "ac_cv_lib_lz4_LZ4F_createCompressionContext=yes,ac_cv_lib_lz4_LZ4F_createCompressionContext=no,lz4"
-
-FILES_${PN} += "${bindir}/apt-key"
-apt-manpages += "doc/apt-key.8"
-
-do_install_append() {
-    #Write the correct apt-architecture to apt.conf
-    APT_CONF=${D}/etc/apt/apt.conf
-    echo 'APT::Architecture "${DPKG_ARCH}";' > ${APT_CONF}
-    oe_libinstall -so -C bin libapt-private ${D}${libdir}/
-}
diff --git a/poky/meta/recipes-devtools/apt/apt_1.8.2.1.bb b/poky/meta/recipes-devtools/apt/apt_1.8.2.1.bb
new file mode 100644
index 0000000..bd1f4f3
--- /dev/null
+++ b/poky/meta/recipes-devtools/apt/apt_1.8.2.1.bb
@@ -0,0 +1,106 @@
+SUMMARY = "Advanced front-end for dpkg"
+LICENSE = "GPLv2.0+"
+SECTION = "base"
+
+# Triehash script taken from https://github.com/julian-klode/triehash
+SRC_URI = "${DEBIAN_MIRROR}/main/a/apt/${BPN}_${PV}.tar.xz \
+           file://triehash \
+           file://0001-Disable-documentation-directory-altogether.patch \
+           file://0001-Fix-musl-build.patch \
+           file://0001-CMakeLists.txt-avoid-changing-install-paths-based-on.patch \
+           "
+     
+SRC_URI_append_class-native = " \
+           file://0001-Do-not-init-tables-from-dpkg-configuration.patch \
+           file://0001-Revert-always-run-dpkg-configure-a-at-the-end-of-our.patch \
+           file://0001-Do-not-configure-packages-on-installation.patch \
+           "
+
+SRC_URI[sha256sum] = "6d447f2e9437ec24e78350b63bb0592bee1f050811d51990b0c783183b0983f8"
+LIC_FILES_CHKSUM = "file://COPYING.GPL;md5=b234ee4d69f5fce4486a80fdaf4a4263"
+
+# the package is taken from snapshots.debian.org; that source is static and goes stale
+# so we check the latest upstream from a directory that does get updated
+UPSTREAM_CHECK_URI = "${DEBIAN_MIRROR}/main/a/apt/"
+
+inherit cmake perlnative bash-completion upstream-version-is-even
+
+BBCLASSEXTEND = "native"
+
+DEPENDS += "virtual/libiconv virtual/libintl db gnutls lz4 zlib bzip2 xz"
+
+EXTRA_OECMAKE_append = " -DCURRENT_VENDOR=debian -DWITH_DOC=False -DUSE_NLS=False -DDPKG_DATADIR=${datadir}/dpkg -DTRIEHASH_EXECUTABLE=${WORKDIR}/triehash"
+
+do_configure_prepend () {
+    echo "set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE BOTH )" >>  ${WORKDIR}/toolchain.cmake
+
+}
+
+# Unfortunately apt hardcodes this all over the place
+FILES_${PN} += "${prefix}/lib/dpkg ${prefix}/lib/apt"
+RDEPENDS_${PN} += "bash perl dpkg"
+
+do_install_append_class-native() {
+    cat > ${D}${sysconfdir}/apt/apt.conf.sample << EOF
+Dir "${STAGING_DIR_NATIVE}/"
+{
+   State "var/lib/apt/"
+   {
+      Lists "#APTCONF#/lists/";
+      status "#ROOTFS#/var/lib/dpkg/status";
+   };
+   Cache "var/cache/apt/"
+   {
+      Archives "archives/";
+      pkgcache "";
+      srcpkgcache "";
+   };
+   Bin "${STAGING_BINDIR_NATIVE}/"
+   {
+      methods "${STAGING_LIBDIR}/apt/methods/";
+      gzip "/bin/gzip";
+      dpkg "dpkg";
+      dpkg-source "dpkg-source";
+      dpkg-buildpackage "dpkg-buildpackage";
+      apt-get "apt-get";
+      apt-cache "apt-cache";
+   };
+   Etc "#APTCONF#"
+   {
+      Preferences "preferences";
+   };
+   Log "var/log/apt";
+};
+
+APT
+{
+  Install-Recommends "true";
+  Immediate-Configure "false";
+  Architecture "i586";
+  Get
+  {
+     Assume-Yes "true";
+  };
+};
+
+Acquire
+{
+  AllowInsecureRepositories "true";
+};
+
+DPkg::Options {"--root=#ROOTFS#";"--admindir=#ROOTFS#/var/lib/dpkg";"--force-all";"--no-debsig"};
+DPkg::Path "";
+EOF
+}
+
+do_install_append_class-target() {
+    #Write the correct apt-architecture to apt.conf
+    APT_CONF=${D}/etc/apt/apt.conf
+    echo 'APT::Architecture "${DPKG_ARCH}";' > ${APT_CONF}
+}
+
+# Avoid non-reproducible -src package
+do_install_append () {
+        sed -i -e "s,${B},,g" \
+            ${B}/apt-pkg/tagfile-keys.cc
+}
diff --git a/poky/meta/recipes-devtools/apt/files/apt.conf b/poky/meta/recipes-devtools/apt/files/apt.conf
deleted file mode 100644
index c95a5b0..0000000
--- a/poky/meta/recipes-devtools/apt/files/apt.conf
+++ /dev/null
@@ -1,42 +0,0 @@
-Dir "${STAGING_DIR_NATIVE}/"
-{
-   State "var/lib/apt/"
-   {
-      Lists "#APTCONF#/lists/";
-      status "#ROOTFS#/var/lib/dpkg/status";
-   };
-   Cache "var/cache/apt/"
-   {
-      Archives "archives/";
-      pkgcache "";
-      srcpkgcache "";
-   };
-   Bin "${STAGING_BINDIR_NATIVE}/"
-   {
-      methods "${STAGING_LIBDIR}/apt/methods/";
-      gzip "/bin/gzip";
-      dpkg "dpkg";
-      dpkg-source "dpkg-source";
-      dpkg-buildpackage "dpkg-buildpackage";
-      apt-get "apt-get";
-      apt-cache "apt-cache";
-   };
-   Etc "#APTCONF#"
-   {
-      Preferences "preferences";
-   };
-};
-
-APT
-{
-  Install-Recommends "true";
-  Immediate-Configure "false";
-  Architecture "i586";
-  Get
-  {
-     Assume-Yes "true";
-     Force-Yes "true"
-  };
-};
-
-DPkg::Options {"--root=#ROOTFS#";"--admindir=#ROOTFS#/var/lib/dpkg";"--force-all";"--no-force-overwrite";"--no-debsig"};
diff --git a/poky/meta/recipes-devtools/apt/files/db_linking_hack.patch b/poky/meta/recipes-devtools/apt/files/db_linking_hack.patch
deleted file mode 100644
index a61d4b0..0000000
--- a/poky/meta/recipes-devtools/apt/files/db_linking_hack.patch
+++ /dev/null
@@ -1,29 +0,0 @@
-Upstream-Status: Backport
-
-Index: apt-0.7.3/configure.ac
-===================================================================
---- apt-0.7.3.orig/configure.ac	2007-07-01 10:38:45.000000000 +0000
-+++ apt-0.7.3/configure.ac	2007-08-21 13:39:26.000000000 +0000
-@@ -67,8 +67,20 @@
-       [AC_DEFINE(HAVE_BDB)
-        BDBLIB="-ldb"
-        AC_MSG_RESULT(yes)],
--      [BDBLIB=""
--       AC_MSG_RESULT(no)]
-+
-+       LIBS="$LIBS -lpthread"
-+       [AC_MSG_CHECKING(if we can link against BerkeleyDB with pthread)
-+        AC_LINK_IFELSE(
-+        [AC_LANG_PROGRAM(
-+         [#include <db.h>],
-+         [int r, s, t; db_version(&r, &s, &t);]
-+        )],
-+        [AC_DEFINE(HAVE_BDB)
-+         BDBLIB="-ldb -lpthread"
-+         AC_MSG_RESULT(yes)],
-+        [BDBLIB=""
-+         AC_MSG_RESULT(no)]
-+      )]       
-     )]
- )
- 
diff --git a/poky/meta/recipes-devtools/apt/files/environment.patch b/poky/meta/recipes-devtools/apt/files/environment.patch
deleted file mode 100644
index 9a03038..0000000
--- a/poky/meta/recipes-devtools/apt/files/environment.patch
+++ /dev/null
@@ -1,15 +0,0 @@
-Upstream-Status: Backport
-
-Index: apt-0.6.46.2/buildlib/environment.mak.in
-===================================================================
---- apt-0.6.46.2.orig/buildlib/environment.mak.in	2007-03-29 11:38:58.000000000 +0100
-+++ apt-0.6.46.2/buildlib/environment.mak.in	2007-03-29 11:39:12.000000000 +0100
-@@ -62,7 +62,7 @@
- 
- # Shared library things
- HOST_OS = @host_os@
--ifneq ($(words $(filter linux-gnu gnu% %gnu,$(HOST_OS))),0)
-+ifneq ($(words $(filter linux-gnu linux-gnueabi gnu% %gnu,$(HOST_OS))),0)
-    SONAME_MAGIC=-Wl,-soname -Wl,
-    LFLAGS_SO=
- else
diff --git a/poky/meta/recipes-devtools/apt/files/no-curl.patch b/poky/meta/recipes-devtools/apt/files/no-curl.patch
deleted file mode 100644
index 0838552..0000000
--- a/poky/meta/recipes-devtools/apt/files/no-curl.patch
+++ /dev/null
@@ -1,54 +0,0 @@
-Upstream-Status: Inappropriate [configuration]
-From 5d61ac822fd9a3871cd5089389c210606232ecdc Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?An=C3=ADbal=20Lim=C3=B3n?= <anibal.limon@linux.intel.com>
-Date: Thu, 26 May 2016 15:34:45 -0500
-Subject: [PATCH] Upstream-Status: Inappropriate [configuration]
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Signed-off-by: Aníbal Limón <anibal.limon@linux.intel.com>
----
- configure.ac     | 7 -------
- methods/makefile | 7 -------
- 2 files changed, 14 deletions(-)
-
-diff --git a/configure.ac b/configure.ac
-index e47f459..cd24264 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -83,13 +83,6 @@ AC_CHECK_HEADER(db.h,
- 
- LIBS="$saveLIBS"
- 
--AC_CHECK_LIB(curl, curl_easy_init,
--     [AC_CHECK_HEADER(curl/curl.h,
--        curl_ok=yes,
--        curl_ok=no)],
--     AC_MSG_ERROR([failed: I need CURL due https support]),
--)
--
- AC_SUBST(BDBLIB)
- 
- HAVE_ZLIB=no
-diff --git a/methods/makefile b/methods/makefile
-index 3274e92..255086b 100644
---- a/methods/makefile
-+++ b/methods/makefile
-@@ -51,13 +51,6 @@ LIB_MAKES = apt-pkg/makefile
- SOURCE = http.cc http_main.cc rfc2553emu.cc connect.cc server.cc
- include $(PROGRAM_H)
- 
--# The https method
--PROGRAM=https
--SLIBS = -lapt-pkg -lcurl $(INTLLIBS) -lresolv
--LIB_MAKES = apt-pkg/makefile
--SOURCE = https.cc server.cc
--include $(PROGRAM_H)
--
- # The ftp method
- PROGRAM=ftp
- SLIBS = -lapt-pkg $(SOCKETLIBS) $(INTLLIBS) -lresolv
--- 
-2.1.4
-
diff --git a/poky/meta/recipes-devtools/automake/automake/automake-replace-w-option-in-shebangs-with-modern-use-warnings.patch b/poky/meta/recipes-devtools/automake/automake/automake-replace-w-option-in-shebangs-with-modern-use-warnings.patch
index 1592c02..0e84c4b 100644
--- a/poky/meta/recipes-devtools/automake/automake/automake-replace-w-option-in-shebangs-with-modern-use-warnings.patch
+++ b/poky/meta/recipes-devtools/automake/automake/automake-replace-w-option-in-shebangs-with-modern-use-warnings.patch
@@ -1,4 +1,4 @@
-From 081385f4d4bba367afad3bff1fa034f5263305e6 Mon Sep 17 00:00:00 2001
+From 857c843d4bcf576467b505eb05a47f3e7d32caaa Mon Sep 17 00:00:00 2001
 From: Serhii Popovych <spopovyc@cisco.com>
 Date: Wed, 10 Feb 2016 17:07:32 +0000
 Subject: [PATCH] perl: Replace -w option in shebangs with modern "use
@@ -23,16 +23,16 @@
  2 files changed, 4 insertions(+), 2 deletions(-)
 
 diff --git a/bin/aclocal.in b/bin/aclocal.in
-index b3715d9..461d453 100644
+index 9a20325..bd185d4 100644
 --- a/bin/aclocal.in
 +++ b/bin/aclocal.in
 @@ -1,4 +1,4 @@
 -#!@PERL@ -w
 +#!@PERL@
- # -*- perl -*-
+ # aclocal - create aclocal.m4 by scanning configure.ac      -*- perl -*-
  # @configure_input@
- 
-@@ -32,6 +32,7 @@ BEGIN
+ # Copyright (C) 1996-2020 Free Software Foundation, Inc.
+@@ -26,6 +26,7 @@ BEGIN
  }
  
  use strict;
@@ -41,16 +41,16 @@
  use Automake::Config;
  use Automake::General;
 diff --git a/bin/automake.in b/bin/automake.in
-index 8377d20..3a66965 100644
+index 5ed404a..d387b8e 100644
 --- a/bin/automake.in
 +++ b/bin/automake.in
 @@ -1,4 +1,4 @@
 -#!@PERL@ -w
 +#!@PERL@
- # -*- perl -*-
+ # automake - create Makefile.in from Makefile.am            -*- perl -*-
  # @configure_input@
- 
-@@ -28,6 +28,7 @@ eval 'case $# in 0) exec @PERL@ -S "$0";; *) exec @PERL@ -S "$0" "$@";; esac'
+ # Copyright (C) 1994-2020 Free Software Foundation, Inc.
+@@ -23,6 +23,7 @@
  package Automake;
  
  use strict;
diff --git a/poky/meta/recipes-devtools/automake/automake_1.16.1.bb b/poky/meta/recipes-devtools/automake/automake_1.16.2.bb
similarity index 89%
rename from poky/meta/recipes-devtools/automake/automake_1.16.1.bb
rename to poky/meta/recipes-devtools/automake/automake_1.16.2.bb
index d82eed3..fd8ed0e 100644
--- a/poky/meta/recipes-devtools/automake/automake_1.16.1.bb
+++ b/poky/meta/recipes-devtools/automake/automake_1.16.2.bb
@@ -28,8 +28,8 @@
             file://0001-build-fix-race-in-parallel-builds.patch \
             "
 
-SRC_URI[md5sum] = "83cc2463a4080efd46a72ba2c9f6b8f5"
-SRC_URI[sha256sum] = "608a97523f97db32f1f5d5615c98ca69326ced2054c9f82e65bade7fc4c9dea8"
+SRC_URI[md5sum] = "f1a14f2ab2b0fb861a011e1d94e589e0"
+SRC_URI[sha256sum] = "b2f361094b410b4acbf4efba7337bdb786335ca09eb2518635a09fb7319ca5c1"
 
 PERL = "${USRBINPATH}/perl"
 PERL_class-native = "${USRBINPATH}/env perl"
diff --git a/poky/meta/recipes-devtools/bison/bison/dont-depend-on-help2man.patch.patch b/poky/meta/recipes-devtools/bison/bison/dont-depend-on-help2man.patch.patch
deleted file mode 100644
index 8a41a3a..0000000
--- a/poky/meta/recipes-devtools/bison/bison/dont-depend-on-help2man.patch.patch
+++ /dev/null
@@ -1,44 +0,0 @@
-From 31bb81ef15c42b10844eb8af8738f672076edf0e Mon Sep 17 00:00:00 2001
-From: Marko Lindqvist <cazfi74@gmail.com>
-Date: Tue, 21 Apr 2015 00:48:45 -0700
-Subject: [PATCH] doc/local.mk: dont-depend-on-help2man.patch
-
-Upstream-Status: Inappropriate
-
-Signed-off-by: Marko Lindqvist <cazfi74@gmail.com>
-
-Updated for bison 3.0.4
-
-Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
-
----
- doc/local.mk | 9 +--------
- 1 file changed, 1 insertion(+), 8 deletions(-)
-
-diff --git a/doc/local.mk b/doc/local.mk
-index d12836e..f9bf332 100644
---- a/doc/local.mk
-+++ b/doc/local.mk
-@@ -101,10 +101,7 @@ endif ! CROSS_COMPILING
- ## Man Pages.  ##
- ## ----------- ##
- 
--dist_man_MANS = $(top_srcdir)/doc/bison.1
--
--EXTRA_DIST += $(dist_man_MANS:.1=.x)
--MAINTAINERCLEANFILES += $(dist_man_MANS)
-+EXTRA_DIST += bison.x
- 
- # Differences to ignore when comparing the man page (the date).
- remove_time_stamp = \
-@@ -127,10 +124,6 @@ $(top_srcdir)/doc/bison.1: $(MAN_DEPS)
- 	fi
- 	$(AM_V_at)rm -f $@*.tmp
- 
--if ENABLE_YACC
--nodist_man_MANS = doc/yacc.1
--endif
--
- ## ----------------------------- ##
- ## Graphviz examples generation. ##
- ## ----------------------------- ##
diff --git a/poky/meta/recipes-devtools/bison/bison_3.5.4.bb b/poky/meta/recipes-devtools/bison/bison_3.6.2.bb
similarity index 91%
rename from poky/meta/recipes-devtools/bison/bison_3.5.4.bb
rename to poky/meta/recipes-devtools/bison/bison_3.6.2.bb
index 124bc41..2ec9381 100644
--- a/poky/meta/recipes-devtools/bison/bison_3.5.4.bb
+++ b/poky/meta/recipes-devtools/bison/bison_3.6.2.bb
@@ -10,11 +10,10 @@
 DEPENDS = "bison-native flex-native"
 
 SRC_URI = "${GNU_MIRROR}/bison/bison-${PV}.tar.xz \
-           file://dont-depend-on-help2man.patch.patch \
            file://add-with-bisonlocaledir.patch \
            file://0001-bison-fix-the-parallel-build.patch \
-"
-SRC_URI[sha256sum] = "4c17e99881978fa32c05933c5262457fa5b2b611668454f8dc2a695cd6b3720c"
+           "
+SRC_URI[sha256sum] = "4a164b5cc971b896ce976bf4b624fab7279e0729cf983a5135df7e4df0970f6e"
 
 # No point in hardcoding path to m4, just use PATH
 EXTRA_OECONF += "M4=m4"
diff --git a/poky/meta/recipes-devtools/btrfs-tools/btrfs-tools_5.4.1.bb b/poky/meta/recipes-devtools/btrfs-tools/btrfs-tools_5.6.1.bb
similarity index 97%
rename from poky/meta/recipes-devtools/btrfs-tools/btrfs-tools_5.4.1.bb
rename to poky/meta/recipes-devtools/btrfs-tools/btrfs-tools_5.6.1.bb
index cdc971c..885d79d 100644
--- a/poky/meta/recipes-devtools/btrfs-tools/btrfs-tools_5.4.1.bb
+++ b/poky/meta/recipes-devtools/btrfs-tools/btrfs-tools_5.6.1.bb
@@ -14,7 +14,7 @@
 DEPENDS_append_class-target = " udev"
 RDEPENDS_${PN} = "libgcc"
 
-SRCREV = "3fc2326d3474a5e4df2449f5e3043f7298501334"
+SRCREV = "2a74d408f4b65d603e42f6e7b6b905ac81825fc9"
 SRC_URI = "git://git.kernel.org/pub/scm/linux/kernel/git/kdave/btrfs-progs.git \
            file://0001-Add-a-possibility-to-specify-where-python-modules-ar.patch \
            "
diff --git a/poky/meta/recipes-devtools/build-compare/build-compare_git.bb b/poky/meta/recipes-devtools/build-compare/build-compare_git.bb
index d2a4b54..74a954d 100644
--- a/poky/meta/recipes-devtools/build-compare/build-compare_git.bb
+++ b/poky/meta/recipes-devtools/build-compare/build-compare_git.bb
@@ -9,9 +9,9 @@
 
 # Date matches entry in build-compare.changes and date of SRCREV.
 #
-SRCREV = "28bf642fcfdab94adb9b847329338005be6f73c7"
+SRCREV = "102d844ce052c6dec6c56ee1d471bde72a1b4633"
 PE = "1"
-PV = "2020.03.31+git${SRCPV}"
+PV = "2020.05.29+git${SRCPV}"
 UPSTREAM_CHECK_COMMITS = "1"
 
 S = "${WORKDIR}/git"
diff --git a/poky/meta/recipes-devtools/ccache/ccache_3.7.7.bb b/poky/meta/recipes-devtools/ccache/ccache_3.7.7.bb
deleted file mode 100644
index 3e7362b..0000000
--- a/poky/meta/recipes-devtools/ccache/ccache_3.7.7.bb
+++ /dev/null
@@ -1,7 +0,0 @@
-require ccache.inc
-
-LICENSE = "GPLv3+"
-LIC_FILES_CHKSUM = "file://LICENSE.adoc;md5=22d514dbc01fdf9a9784334b6b59417a"
-
-SRC_URI[md5sum] = "500d7bd9ebc6ee3105d7fc332c1ef395"
-SRC_URI[sha256sum] = "9b61f7fab2ec15305ee8382b03365503232dfb04b57414e7b0433768d530fa8a"
diff --git a/poky/meta/recipes-devtools/ccache/ccache_3.7.9.bb b/poky/meta/recipes-devtools/ccache/ccache_3.7.9.bb
new file mode 100644
index 0000000..a4de6c9
--- /dev/null
+++ b/poky/meta/recipes-devtools/ccache/ccache_3.7.9.bb
@@ -0,0 +1,7 @@
+require ccache.inc
+
+LICENSE = "GPLv3+"
+LIC_FILES_CHKSUM = "file://LICENSE.adoc;md5=22d514dbc01fdf9a9784334b6b59417a"
+
+SRC_URI[md5sum] = "a4a38afc62ed189904357739fd8f3fb8"
+SRC_URI[sha256sum] = "92838e2133c9e704fdab9ee2608dad86c99021278b9ac47d065aa8ff2ea8ce36"
diff --git a/poky/meta/recipes-devtools/cmake/cmake-native_3.16.5.bb b/poky/meta/recipes-devtools/cmake/cmake-native_3.17.3.bb
similarity index 100%
rename from poky/meta/recipes-devtools/cmake/cmake-native_3.16.5.bb
rename to poky/meta/recipes-devtools/cmake/cmake-native_3.17.3.bb
diff --git a/poky/meta/recipes-devtools/cmake/cmake.inc b/poky/meta/recipes-devtools/cmake/cmake.inc
index 09949b5..7f0307c 100644
--- a/poky/meta/recipes-devtools/cmake/cmake.inc
+++ b/poky/meta/recipes-devtools/cmake/cmake.inc
@@ -10,8 +10,8 @@
 BUGTRACKER = "http://public.kitware.com/Bug/my_view_page.php"
 SECTION = "console/utils"
 LICENSE = "BSD-3-Clause"
-LIC_FILES_CHKSUM = "file://Copyright.txt;md5=622747147b46f22e1953876a7cba3323 \
-                    file://Source/cmake.h;md5=4494dee184212fc89c469c3acd555a14;beginline=1;endline=3 \
+LIC_FILES_CHKSUM = "file://Copyright.txt;md5=c721f56fce89ba2eadc2fdd8ba1f4d83 \
+                    file://Source/cmake.h;beginline=1;endline=3;md5=4494dee184212fc89c469c3acd555a14 \
                     "
 
 CMAKE_MAJOR_VERSION = "${@'.'.join(d.getVar('PV').split('.')[0:2])}"
@@ -22,7 +22,6 @@
            file://0004-Fail-silently-if-system-Qt-installation-is-broken.patch \
 "
 
-SRC_URI[md5sum] = "d86ccaf3d2462b6b5947919abe5b9f15"
-SRC_URI[sha256sum] = "5f760b50b8ecc9c0c37135fae5fbf00a2fef617059aa9d61c1bb91653e5a8bfc"
+SRC_URI[sha256sum] = "0bd60d512275dc9f6ef2a2865426a184642ceb3761794e6b65bff233b91d8c40"
 
 UPSTREAM_CHECK_REGEX = "cmake-(?P<pver>\d+(\.\d+)+)\.tar"
diff --git a/poky/meta/recipes-devtools/cmake/cmake/0001-CMakeDetermineSystem-use-oe-environment-vars-to-load.patch b/poky/meta/recipes-devtools/cmake/cmake/0001-CMakeDetermineSystem-use-oe-environment-vars-to-load.patch
index e2a58d2..f5c1a21 100644
--- a/poky/meta/recipes-devtools/cmake/cmake/0001-CMakeDetermineSystem-use-oe-environment-vars-to-load.patch
+++ b/poky/meta/recipes-devtools/cmake/cmake/0001-CMakeDetermineSystem-use-oe-environment-vars-to-load.patch
@@ -1,4 +1,4 @@
-From ab272d703ce77f323aa1285526559c9efbf85834 Mon Sep 17 00:00:00 2001
+From d4aa2dbdc69774ad668756586d59331ad215a2c6 Mon Sep 17 00:00:00 2001
 From: Cody P Schafer <dev@codyps.com>
 Date: Thu, 27 Apr 2017 11:35:05 -0400
 Subject: [PATCH] CMakeDetermineSystem: use oe environment vars to load default
diff --git a/poky/meta/recipes-devtools/cmake/cmake/0002-cmake-Prevent-the-detection-of-Qt5.patch b/poky/meta/recipes-devtools/cmake/cmake/0002-cmake-Prevent-the-detection-of-Qt5.patch
index 61c8f27..cf1dda7 100644
--- a/poky/meta/recipes-devtools/cmake/cmake/0002-cmake-Prevent-the-detection-of-Qt5.patch
+++ b/poky/meta/recipes-devtools/cmake/cmake/0002-cmake-Prevent-the-detection-of-Qt5.patch
@@ -1,4 +1,4 @@
-From 5a86c7fa987bd407f228176df2abeffd015be9ea Mon Sep 17 00:00:00 2001
+From 126994379ea75c8826874656bb55f955182ae911 Mon Sep 17 00:00:00 2001
 From: Otavio Salvador <otavio@ossystems.com.br>
 Date: Wed, 17 Jan 2018 10:02:14 -0200
 Subject: [PATCH] cmake: Prevent the detection of Qt5
@@ -25,7 +25,7 @@
  7 files changed, 8 insertions(+), 9 deletions(-)
 
 diff --git a/Source/QtDialog/CMakeLists.txt b/Source/QtDialog/CMakeLists.txt
-index cb89d19..9e68981 100644
+index 98dd0e2..252302b 100644
 --- a/Source/QtDialog/CMakeLists.txt
 +++ b/Source/QtDialog/CMakeLists.txt
 @@ -3,7 +3,7 @@
@@ -38,18 +38,18 @@
    include_directories(${Qt5Widgets_INCLUDE_DIRS})
    add_definitions(${Qt5Widgets_DEFINITONS})
 diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt
-index 57fa7fc..d50c146 100644
+index aff7383..e220503 100644
 --- a/Tests/CMakeLists.txt
 +++ b/Tests/CMakeLists.txt
-@@ -1329,7 +1329,7 @@ ${CMake_SOURCE_DIR}/Utilities/Release/push.bash --dir dev -- '${CMake_BUILD_NIGH
+@@ -215,7 +215,7 @@ if(BUILD_TESTING)
      set(CMake_TEST_Qt5 1)
    endif()
    if(CMake_TEST_Qt5)
 -    find_package(Qt5Widgets QUIET NO_MODULE)
 +    #find_package(Qt5Widgets QUIET NO_MODULE)
    endif()
-   if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
-     add_subdirectory(Qt5Autogen)
+ 
+   if(NOT CMake_TEST_EXTERNAL_CMAKE)
 diff --git a/Tests/Qt4And5Automoc/CMakeLists.txt b/Tests/Qt4And5Automoc/CMakeLists.txt
 index ad74961..a9dd74b 100644
 --- a/Tests/Qt4And5Automoc/CMakeLists.txt
@@ -96,10 +96,10 @@
  set(CMAKE_CXX_STANDARD 11)
  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output/bin)
 diff --git a/Tests/RunCMake/CMakeLists.txt b/Tests/RunCMake/CMakeLists.txt
-index 6b2f117..1002005 100644
+index e9f8bca..3a2da34 100644
 --- a/Tests/RunCMake/CMakeLists.txt
 +++ b/Tests/RunCMake/CMakeLists.txt
-@@ -376,7 +376,7 @@ else()
+@@ -396,7 +396,7 @@ else()
  endif()
  
  find_package(Qt4 QUIET)
diff --git a/poky/meta/recipes-devtools/cmake/cmake_3.16.5.bb b/poky/meta/recipes-devtools/cmake/cmake_3.17.3.bb
similarity index 100%
rename from poky/meta/recipes-devtools/cmake/cmake_3.16.5.bb
rename to poky/meta/recipes-devtools/cmake/cmake_3.17.3.bb
diff --git a/poky/meta/recipes-devtools/createrepo-c/createrepo-c_0.15.7.bb b/poky/meta/recipes-devtools/createrepo-c/createrepo-c_0.15.10.bb
similarity index 95%
rename from poky/meta/recipes-devtools/createrepo-c/createrepo-c_0.15.7.bb
rename to poky/meta/recipes-devtools/createrepo-c/createrepo-c_0.15.10.bb
index c6a53ff..13bfa21 100644
--- a/poky/meta/recipes-devtools/createrepo-c/createrepo-c_0.15.7.bb
+++ b/poky/meta/recipes-devtools/createrepo-c/createrepo-c_0.15.10.bb
@@ -8,7 +8,7 @@
            file://0001-Do-not-set-PYTHON_INSTALL_DIR-by-running-python.patch \
            "
 
-SRCREV = "4ab6b56b8b718396386982afba4ade297c14d91a"
+SRCREV = "9f3f3be6359d8f9b6b269e28d9ae1f279cc5f3aa"
 
 S = "${WORKDIR}/git"
 
diff --git a/poky/meta/recipes-devtools/dpkg/dpkg/tweak-options-require-tar-1.27.patch b/poky/meta/recipes-devtools/dpkg/dpkg/tweak-options-require-tar-1.27.patch
index e911991..ac59dce 100644
--- a/poky/meta/recipes-devtools/dpkg/dpkg/tweak-options-require-tar-1.27.patch
+++ b/poky/meta/recipes-devtools/dpkg/dpkg/tweak-options-require-tar-1.27.patch
@@ -1,3 +1,8 @@
+From 48bcc51ce042d1b779b34fae454c52b15bdd9cae Mon Sep 17 00:00:00 2001
+From: Kai Kang <kai.kang@windriver.com>
+Date: Fri, 22 Feb 2019 01:47:16 -0500
+Subject: [PATCH] dpkg: 1.18.25 -> 1.19.4
+
 GNU tar >= 1.27 is required for --owner=NAME:ID and --group=NAME:ID. And fails
 to build .deb packages with error:
 
@@ -11,9 +16,13 @@
 Upstream-Status: Inappropriate [cross build specific]
 
 Signed-off-by: Kai Kang <kai.kang@windriver.com>
+
 ---
+ dpkg-deb/build.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
 diff --git a/dpkg-deb/build.c b/dpkg-deb/build.c
-index 68d187511..86fe22e25 100644
+index 8436839..67c0c20 100644
 --- a/dpkg-deb/build.c
 +++ b/dpkg-deb/build.c
 @@ -462,7 +462,7 @@ tarball_pack(const char *dir, filenames_feed_func *tar_filenames_feeder,
diff --git a/poky/meta/recipes-devtools/dpkg/dpkg_1.19.7.bb b/poky/meta/recipes-devtools/dpkg/dpkg_1.20.0.bb
similarity index 87%
rename from poky/meta/recipes-devtools/dpkg/dpkg_1.19.7.bb
rename to poky/meta/recipes-devtools/dpkg/dpkg_1.20.0.bb
index 50fe54d..1e822bb 100644
--- a/poky/meta/recipes-devtools/dpkg/dpkg_1.19.7.bb
+++ b/poky/meta/recipes-devtools/dpkg/dpkg_1.20.0.bb
@@ -19,5 +19,5 @@
                                 file://tweak-options-require-tar-1.27.patch \
 "
 
-SRC_URI[md5sum] = "60f57c5494e6dfa177504d47bfa0e383"
-SRC_URI[sha256sum] = "4c27fededf620c0aa522fff1a48577ba08144445341257502e7730f2b1a296e8"
+SRC_URI[md5sum] = "f88f077236a3ff3decae3b25c989893d"
+SRC_URI[sha256sum] = "b633cc2b0e030efb61e11029d8a3fb1123f719864c9992da2e52b471c96d0900"
diff --git a/poky/meta/recipes-devtools/gdb/gdb-9.1.inc b/poky/meta/recipes-devtools/gdb/gdb-9.2.inc
similarity index 88%
rename from poky/meta/recipes-devtools/gdb/gdb-9.1.inc
rename to poky/meta/recipes-devtools/gdb/gdb-9.2.inc
index d019e6b..017b61e 100644
--- a/poky/meta/recipes-devtools/gdb/gdb-9.1.inc
+++ b/poky/meta/recipes-devtools/gdb/gdb-9.2.inc
@@ -17,5 +17,5 @@
            file://0010-Fix-invalid-sigprocmask-call.patch \
            file://0011-gdbserver-ctrl-c-handling.patch \
            "
-SRC_URI[md5sum] = "f7e9f6236c425097d9e5f18a6ac40655"
-SRC_URI[sha256sum] = "699e0ec832fdd2f21c8266171ea5bf44024bd05164fdf064e4d10cc4cf0d1737"
+SRC_URI[md5sum] = "db95524e554870209ab7d9f8fd8dc557"
+SRC_URI[sha256sum] = "360cd7ae79b776988e89d8f9a01c985d0b1fa21c767a4295e5f88cb49175c555"
diff --git a/poky/meta/recipes-devtools/gdb/gdb-cross-canadian_9.1.bb b/poky/meta/recipes-devtools/gdb/gdb-cross-canadian_9.2.bb
similarity index 100%
rename from poky/meta/recipes-devtools/gdb/gdb-cross-canadian_9.1.bb
rename to poky/meta/recipes-devtools/gdb/gdb-cross-canadian_9.2.bb
diff --git a/poky/meta/recipes-devtools/gdb/gdb-cross_9.1.bb b/poky/meta/recipes-devtools/gdb/gdb-cross_9.2.bb
similarity index 100%
rename from poky/meta/recipes-devtools/gdb/gdb-cross_9.1.bb
rename to poky/meta/recipes-devtools/gdb/gdb-cross_9.2.bb
diff --git a/poky/meta/recipes-devtools/gdb/gdb_9.1.bb b/poky/meta/recipes-devtools/gdb/gdb_9.2.bb
similarity index 100%
rename from poky/meta/recipes-devtools/gdb/gdb_9.1.bb
rename to poky/meta/recipes-devtools/gdb/gdb_9.2.bb
diff --git a/poky/meta/recipes-devtools/gnu-config/gnu-config_git.bb b/poky/meta/recipes-devtools/gnu-config/gnu-config_git.bb
index 48b7e6d..9d1874c 100644
--- a/poky/meta/recipes-devtools/gnu-config/gnu-config_git.bb
+++ b/poky/meta/recipes-devtools/gnu-config/gnu-config_git.bb
@@ -8,8 +8,8 @@
 
 INHIBIT_DEFAULT_DEPS = "1"
 
-SRCREV = "5256817ace8493502ec88501a19e4051c2e220b0"
-PV = "20200117+git${SRCPV}"
+SRCREV = "e78c96e5288993aaea3ec44e5c6ee755c668da79"
+PV = "20200515+git${SRCPV}"
 
 SRC_URI = "git://git.savannah.gnu.org/config.git \
            file://gnu-configize.in"
diff --git a/poky/meta/recipes-devtools/go/go-1.14.inc b/poky/meta/recipes-devtools/go/go-1.14.inc
index c52593d..d729b65 100644
--- a/poky/meta/recipes-devtools/go/go-1.14.inc
+++ b/poky/meta/recipes-devtools/go/go-1.14.inc
@@ -1,7 +1,7 @@
 require go-common.inc
 
 GO_BASEVERSION = "1.14"
-GO_MINOR = ".1"
+GO_MINOR = ".3"
 PV .= "${GO_MINOR}"
 FILESEXTRAPATHS_prepend := "${FILE_DIRNAME}/go-${GO_BASEVERSION}:"
 
@@ -18,5 +18,4 @@
     file://0008-use-GOBUILDMODE-to-set-buildmode.patch \
 "
 SRC_URI_append_libc-musl = " file://0009-ld-replace-glibc-dynamic-linker-with-musl.patch"
-
-SRC_URI[main.sha256sum] = "2ad2572115b0d1b4cb4c138e6b3a31cee6294cb48af75ee86bec3dca04507676"
+SRC_URI[main.sha256sum] = "93023778d4d1797b7bc6a53e86c3a9b150c923953225f8a48a2d5fabc971af56"
diff --git a/poky/meta/recipes-devtools/help2man/help2man-native_1.47.11.bb b/poky/meta/recipes-devtools/help2man/help2man-native_1.47.15.bb
similarity index 69%
rename from poky/meta/recipes-devtools/help2man/help2man-native_1.47.11.bb
rename to poky/meta/recipes-devtools/help2man/help2man-native_1.47.15.bb
index a60e851..4f80a2b 100644
--- a/poky/meta/recipes-devtools/help2man/help2man-native_1.47.11.bb
+++ b/poky/meta/recipes-devtools/help2man/help2man-native_1.47.15.bb
@@ -1,12 +1,11 @@
 SUMMARY = "Program for creating simple man pages"
 SECTION = "devel"
 LICENSE = "GPLv3"
-LIC_FILES_CHKSUM = "file://COPYING;md5=d32239bcb673463ab874e80d47fae504"
+LIC_FILES_CHKSUM = "file://COPYING;md5=1ebbd3e34237af26da5dc08a4e440464"
 DEPENDS = "autoconf-native automake-native"
 
 SRC_URI = "${GNU_MIRROR}/${BPN}/${BPN}-${PV}.tar.xz"
-SRC_URI[md5sum] = "dd322adcaede5bd5eaed075ff8971bc1"
-SRC_URI[sha256sum] = "5985b257f86304c8791842c0c807a37541d0d6807ee973000cf8a3fe6ad47b88"
+SRC_URI[sha256sum] = "c25a35b30eceb315361484b0ff1f81c924e8ee5c8881576f1ee762f001dbcd1c"
 
 inherit autotools native
 
diff --git a/poky/meta/recipes-devtools/jquery/jquery_3.5.0.bb b/poky/meta/recipes-devtools/jquery/jquery_3.5.1.bb
similarity index 67%
rename from poky/meta/recipes-devtools/jquery/jquery_3.5.0.bb
rename to poky/meta/recipes-devtools/jquery/jquery_3.5.1.bb
index 5c6f9cd..b4d7e80 100644
--- a/poky/meta/recipes-devtools/jquery/jquery_3.5.0.bb
+++ b/poky/meta/recipes-devtools/jquery/jquery_3.5.1.bb
@@ -2,7 +2,7 @@
 HOMEPAGE = "https://jquery.com/"
 LICENSE = "MIT"
 SECTION = "devel"
-LIC_FILES_CHKSUM = "file://${WORKDIR}/${BP}.js;startline=8;endline=10;md5=b1e67ece919e852643f1541a54492d65"
+LIC_FILES_CHKSUM = "file://${WORKDIR}/${BP}.js;beginline=8;endline=10;md5=ebd7bc5d23ab165188e526a0c65d24bb"
 
 SRC_URI = "\
     https://code.jquery.com/${BP}.js;name=js \
@@ -10,9 +10,9 @@
     https://code.jquery.com/${BP}.min.map;name=map \
     "
 
-SRC_URI[js.sha256sum] = "aff01a147aeccc9b70a5efad1f2362fd709f3316296ec460d94aa7d31decdb37"
-SRC_URI[min.sha256sum] = "c4dccdd9ae25b64078e0c73f273de94f8894d5c99e4741645ece29aeefc9c5a4"
-SRC_URI[map.sha256sum] = "3149351c8cbc3fb230bbf6188617c7ffda77d9e14333f4f5f0aa1aae379df892"
+SRC_URI[js.sha256sum] = "416a3b2c3bf16d64f6b5b6d0f7b079df2267614dd6847fc2f3271b4409233c37"
+SRC_URI[min.sha256sum] = "f7f6a5894f1d19ddad6fa392b2ece2c5e578cbf7da4ea805b6885eb6985b6e3d"
+SRC_URI[map.sha256sum] = "511d6f6d3e7acec78cd2505f04282b6e01329b4c24931f39d91739d0d1ddeef8"
 
 UPSTREAM_CHECK_REGEX = "jquery-(?P<pver>\d+(\.\d+)+)\.js"
 
diff --git a/poky/meta/recipes-devtools/json-c/json-c/add-disable-werror-option-to-configure.patch b/poky/meta/recipes-devtools/json-c/json-c/add-disable-werror-option-to-configure.patch
deleted file mode 100644
index 0c20c84..0000000
--- a/poky/meta/recipes-devtools/json-c/json-c/add-disable-werror-option-to-configure.patch
+++ /dev/null
@@ -1,45 +0,0 @@
-json-c: Backport --disable-werror patch to allow compilation under icecc
-
-icecc preprocesses source files locally before shipping them off to be compiled
-on remote hosts. This preprocessing removes comments, including /* fallthough */
-comments in switch statements that normally prevent an implicit-fallthrough
-warning, see https://github.com/icecc/icecream/issues/419
-
-Rather than turning off -Werror, the upstream project has implemented a
-configure option, --disable-werror, in response to Ross's
-https://github.com/json-c/json-c/issues/489
-
-This patch from
-https://github.com/json-c/json-c/commit/21c886534f8927fdc0fb5f8647394f3e0e0874b8
-
-Upstream-Status: Backport [Not yet released]
-Signed-off-by: Douglas Royds <douglas.royds@taitradio.com>
-
-From 21c886534f8927fdc0fb5f8647394f3e0e0874b8 Mon Sep 17 00:00:00 2001
-From: Pierce Lopez <pierce.lopez@gmail.com>
-Date: Sun, 9 Jun 2019 10:52:08 -0400
-Subject: [PATCH] build: add --disable-werror option to configure
-
-to omit -Werror compiler option
----
- configure.ac | 7 ++++++-
- 1 file changed, 6 insertions(+), 1 deletion(-)
-
-diff --git a/configure.ac b/configure.ac
-index 272ea6af9c..798fd5b747 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -165,7 +165,12 @@ AS_IF([test "x$enable_Bsymbolic" = "xcheck"],
- AS_IF([test "x$enable_Bsymbolic" = "xyes"], [JSON_BSYMBOLIC_LDFLAGS=-Wl[,]-Bsymbolic-functions])
- AC_SUBST(JSON_BSYMBOLIC_LDFLAGS)
- 
--AX_APPEND_COMPILE_FLAGS([-Wall -Werror -Wcast-qual -Wno-error=deprecated-declarations])
-+AC_ARG_ENABLE([werror],
-+    AS_HELP_STRING([--disable-werror], [avoid treating compiler warnings as fatal errors]))
-+
-+AS_IF([test "x$enable_werror" != "xno"], [AX_APPEND_COMPILE_FLAGS([-Werror])])
-+
-+AX_APPEND_COMPILE_FLAGS([-Wall -Wcast-qual -Wno-error=deprecated-declarations])
- AX_APPEND_COMPILE_FLAGS([-Wextra -Wwrite-string -Wno-unused-parameter])
- AX_APPEND_COMPILE_FLAGS([-D_GNU_SOURCE])
- 
diff --git a/poky/meta/recipes-devtools/json-c/json-c_0.13.1.bb b/poky/meta/recipes-devtools/json-c/json-c_0.14.bb
similarity index 67%
rename from poky/meta/recipes-devtools/json-c/json-c_0.13.1.bb
rename to poky/meta/recipes-devtools/json-c/json-c_0.14.bb
index 522879f..99fde87 100644
--- a/poky/meta/recipes-devtools/json-c/json-c_0.13.1.bb
+++ b/poky/meta/recipes-devtools/json-c/json-c_0.14.bb
@@ -4,19 +4,14 @@
 LICENSE = "MIT"
 LIC_FILES_CHKSUM = "file://COPYING;md5=de54b60fbbc35123ba193fea8ee216f2"
 
-SRC_URI = "https://s3.amazonaws.com/json-c_releases/releases/${BP}.tar.gz \
-           file://add-disable-werror-option-to-configure.patch \
-           "
-SRC_URI[md5sum] = "04969ad59cc37bddd83741a08b98f350"
-SRC_URI[sha256sum] = "b87e608d4d3f7bfdd36ef78d56d53c74e66ab278d318b71e6002a369d36f4873"
+SRC_URI = "https://s3.amazonaws.com/json-c_releases/releases/${BP}.tar.gz"
+SRC_URI[sha256sum] = "b377de08c9b23ca3b37d9a9828107dff1de5ce208ff4ebb35005a794f30c6870"
 
 UPSTREAM_CHECK_URI = "https://github.com/${BPN}/${BPN}/releases"
 UPSTREAM_CHECK_REGEX = "json-c-(?P<pver>\d+(\.\d+)+)-\d+"
 
 RPROVIDES_${PN} = "libjson"
 
-inherit autotools
-
-EXTRA_OECONF = "--disable-werror"
+inherit cmake
 
 BBCLASSEXTEND = "native nativesdk"
diff --git a/poky/meta/recipes-devtools/libmodulemd/libmodulemd/0002-meson.build-do-not-install-python-gi-bindings.patch b/poky/meta/recipes-devtools/libmodulemd/libmodulemd/0002-meson.build-do-not-install-python-gi-bindings.patch
deleted file mode 100644
index a97fb73..0000000
--- a/poky/meta/recipes-devtools/libmodulemd/libmodulemd/0002-meson.build-do-not-install-python-gi-bindings.patch
+++ /dev/null
@@ -1,23 +0,0 @@
-From d7eeac90fe02ccf5c5e4334e41ec75fc33803643 Mon Sep 17 00:00:00 2001
-From: Alexander Kanavin <alex.kanavin@gmail.com>
-Date: Tue, 31 Mar 2020 16:12:28 +0200
-Subject: [PATCH] meson.build: do not install python gi bindings
-
-These are unnecessary for oe-core, and the install location
-is incorrectly determined using native python.
-
-Upstream-Status: Inappropriate [oe-core specific]
-Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
----
- meson.build | 1 -
- 1 file changed, 1 deletion(-)
-
-diff --git a/meson.build b/meson.build
-index a8b02b4..8ff737b 100644
---- a/meson.build
-+++ b/meson.build
-@@ -171,4 +171,3 @@ configure_file(
- )
- 
- subdir('modulemd')
--subdir('bindings/python')
diff --git a/poky/meta/recipes-devtools/libmodulemd/libmodulemd_git.bb b/poky/meta/recipes-devtools/libmodulemd/libmodulemd_git.bb
index d440e60..fda01b8 100644
--- a/poky/meta/recipes-devtools/libmodulemd/libmodulemd_git.bb
+++ b/poky/meta/recipes-devtools/libmodulemd/libmodulemd_git.bb
@@ -4,17 +4,16 @@
 
 SRC_URI = "git://github.com/fedora-modularity/libmodulemd;protocol=https \
            file://0001-modulemd-generate-the-manpage-only-if-the-feature-is.patch \
-           file://0002-meson.build-do-not-install-python-gi-bindings.patch \
            "
 
-PV = "2.9.2"
-SRCREV = "780750eab8a0587b20d033f335301f16d00ab9c9"
+PV = "2.9.4"
+SRCREV = "c7254db07b21495fc9bd247c5b17ee20149c05e3"
 
 S = "${WORKDIR}/git"
 
-inherit meson gobject-introspection
+inherit meson gobject-introspection python3-dir
 
-EXTRA_OEMESON = "-Ddeveloper_build=false -Dwith_docs=false -Drpmio=disabled -Dlibmagic=disabled -Dwith_manpages=disabled"
+EXTRA_OEMESON = "-Ddeveloper_build=false -Dwith_docs=false -Drpmio=disabled -Dlibmagic=disabled -Dwith_manpages=disabled -Dgobject_overrides_dir_py3=${PYTHON_SITEPACKAGES_DIR}/gi/overrides"
 
 DEPENDS += "glib-2.0 libyaml glib-2.0-native python3"
 
@@ -23,3 +22,5 @@
 GIR_MESON_OPTION = 'skip_introspection'
 GIR_MESON_ENABLE_FLAG = 'false'
 GIR_MESON_DISABLE_FLAG = 'true'
+
+FILES_${PN} += "${libdir}/${PYTHON_DIR}/*"
diff --git a/poky/meta/recipes-devtools/librepo/librepo_1.11.2.bb b/poky/meta/recipes-devtools/librepo/librepo_1.11.3.bb
similarity index 93%
rename from poky/meta/recipes-devtools/librepo/librepo_1.11.2.bb
rename to poky/meta/recipes-devtools/librepo/librepo_1.11.3.bb
index 6a0a59f..3e74531 100644
--- a/poky/meta/recipes-devtools/librepo/librepo_1.11.2.bb
+++ b/poky/meta/recipes-devtools/librepo/librepo_1.11.3.bb
@@ -8,7 +8,7 @@
            file://0004-Set-gpgme-variables-with-pkg-config-not-with-cmake-m.patch \
            "
 
-SRCREV = "67c2d1f83f1bf87be3f26ba730fce7fbdf0c9fba"
+SRCREV = "59b3f76ca6e79786a213cda72ecafa232d30553f"
 
 S = "${WORKDIR}/git"
 
diff --git a/poky/meta/recipes-devtools/meson/meson.inc b/poky/meta/recipes-devtools/meson/meson.inc
index 0a58c97..12bc086 100644
--- a/poky/meta/recipes-devtools/meson/meson.inc
+++ b/poky/meta/recipes-devtools/meson/meson.inc
@@ -9,16 +9,14 @@
 
 SRC_URI = "https://github.com/mesonbuild/meson/releases/download/${PV}/meson-${PV}.tar.gz \
            file://0001-gtkdoc-fix-issues-that-arise-when-cross-compiling.patch \
-           file://0002-gobject-introspection-determine-g-ir-scanner-and-g-i.patch \
            file://0003-native_bindir.patch \
            file://0001-python-module-do-not-manipulate-the-environment-when.patch \
            file://disable-rpath-handling.patch \
            file://cross-prop-default.patch \
-           file://0001-mesonbuild-environment.py-check-environment-for-vari.patch \
            file://0001-modules-python.py-do-not-substitute-python-s-install.patch \
+           file://0001-gnome.py-prefix-g-i-paths-with-PKG_CONFIG_SYSROOT_DI.patch \
            "
-SRC_URI[sha256sum] = "3e8f830f33184397c2eb0b651ec502adb63decb28978bdc84b3558d71284c21f"
-SRC_URI[md5sum] = "80303535995fcae72bdb887df102b421"
+SRC_URI[sha256sum] = "a7716eeae8f8dff002e4147642589ab6496ff839e4376a5aed761f83c1fa0455"
 
 SRC_URI_append_class-native = " \
     file://0001-Make-CPU-family-warnings-fatal.patch \
diff --git a/poky/meta/recipes-devtools/meson/meson/0001-Make-CPU-family-warnings-fatal.patch b/poky/meta/recipes-devtools/meson/meson/0001-Make-CPU-family-warnings-fatal.patch
index e64488b..01a8bb3 100644
--- a/poky/meta/recipes-devtools/meson/meson/0001-Make-CPU-family-warnings-fatal.patch
+++ b/poky/meta/recipes-devtools/meson/meson/0001-Make-CPU-family-warnings-fatal.patch
@@ -1,4 +1,4 @@
-From ee638fd4a299bfc53a2238e9f71ae310c8d97460 Mon Sep 17 00:00:00 2001
+From 830db2c7a136b2446d740c9ca025374352ffd16d Mon Sep 17 00:00:00 2001
 From: Ross Burton <ross.burton@intel.com>
 Date: Tue, 3 Jul 2018 13:59:09 +0100
 Subject: [PATCH] Make CPU family warnings fatal
@@ -12,10 +12,10 @@
  2 files changed, 2 insertions(+), 4 deletions(-)
 
 diff --git a/mesonbuild/envconfig.py b/mesonbuild/envconfig.py
-index 0f277a7..24578ea 100644
+index 17058df..18bbf86 100644
 --- a/mesonbuild/envconfig.py
 +++ b/mesonbuild/envconfig.py
-@@ -192,7 +192,7 @@ class MachineInfo:
+@@ -225,7 +225,7 @@ class MachineInfo:
 
          cpu_family = literal['cpu_family']
          if cpu_family not in known_cpu_families:
@@ -25,10 +25,10 @@
          endian = literal['endian']
          if endian not in ('little', 'big'):
 diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
-index dc8b14f..3aab71e 100644
+index a2f78a4..59fcb07 100644
 --- a/mesonbuild/environment.py
 +++ b/mesonbuild/environment.py
-@@ -354,9 +354,7 @@ def detect_cpu_family(compilers: CompilersDict) -> str:
+@@ -364,9 +364,7 @@ def detect_cpu_family(compilers: CompilersDict) -> str:
          trial = 'parisc'
 
      if trial not in known_cpu_families:
diff --git a/poky/meta/recipes-devtools/meson/meson/0001-gnome.py-prefix-g-i-paths-with-PKG_CONFIG_SYSROOT_DI.patch b/poky/meta/recipes-devtools/meson/meson/0001-gnome.py-prefix-g-i-paths-with-PKG_CONFIG_SYSROOT_DI.patch
new file mode 100644
index 0000000..35c18f0
--- /dev/null
+++ b/poky/meta/recipes-devtools/meson/meson/0001-gnome.py-prefix-g-i-paths-with-PKG_CONFIG_SYSROOT_DI.patch
@@ -0,0 +1,41 @@
+From 7be634fa9705d0367f48a91305f9acb642ff0a11 Mon Sep 17 00:00:00 2001
+From: Alexander Kanavin <alex.kanavin@gmail.com>
+Date: Wed, 27 May 2020 16:43:05 +0000
+Subject: [PATCH] gnome.py: prefix g-i paths with PKG_CONFIG_SYSROOT_DIR
+
+When using sysroots for builds, the standard target paths for the
+tools need to be prefixed (pkg-config is not clever enough to
+determine when a custom variable is a path)
+
+Upstream-Status: Pending
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+---
+ mesonbuild/modules/gnome.py | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/mesonbuild/modules/gnome.py b/mesonbuild/modules/gnome.py
+index 89d5d5d..d75f2e5 100644
+--- a/mesonbuild/modules/gnome.py
++++ b/mesonbuild/modules/gnome.py
+@@ -739,17 +739,17 @@ class GnomeModule(ExtensionModule):
+         if giscanner.found():
+             giscanner_path = giscanner.get_command()[0]
+             if not any(x in giscanner_path for x in gi_util_dirs_check):
+-                giscanner = self.gir_dep.get_pkgconfig_variable('g_ir_scanner', {})
++                giscanner = os.environ['PKG_CONFIG_SYSROOT_DIR'] + self.gir_dep.get_pkgconfig_variable('g_ir_scanner', {})
+         else:
+-            giscanner = self.gir_dep.get_pkgconfig_variable('g_ir_scanner', {})
++            giscanner = os.environ['PKG_CONFIG_SYSROOT_DIR'] + self.gir_dep.get_pkgconfig_variable('g_ir_scanner', {})
+ 
+         gicompiler = self.interpreter.find_program_impl('g-ir-compiler')
+         if gicompiler.found():
+             gicompiler_path = gicompiler.get_command()[0]
+             if not any(x in gicompiler_path for x in gi_util_dirs_check):
+-                gicompiler = self.gir_dep.get_pkgconfig_variable('g_ir_compiler', {})
++                gicompiler = os.environ['PKG_CONFIG_SYSROOT_DIR'] + self.gir_dep.get_pkgconfig_variable('g_ir_compiler', {})
+         else:
+-            gicompiler = self.gir_dep.get_pkgconfig_variable('g_ir_compiler', {})
++            gicompiler = os.environ['PKG_CONFIG_SYSROOT_DIR'] + self.gir_dep.get_pkgconfig_variable('g_ir_compiler', {})
+ 
+         ns = kwargs.pop('namespace')
+         nsversion = kwargs.pop('nsversion')
diff --git a/poky/meta/recipes-devtools/meson/meson/0001-mesonbuild-environment.py-check-environment-for-vari.patch b/poky/meta/recipes-devtools/meson/meson/0001-mesonbuild-environment.py-check-environment-for-vari.patch
deleted file mode 100644
index f445623..0000000
--- a/poky/meta/recipes-devtools/meson/meson/0001-mesonbuild-environment.py-check-environment-for-vari.patch
+++ /dev/null
@@ -1,26 +0,0 @@
-From a72dc2b1cddcf180ce782860896deae0b12d5000 Mon Sep 17 00:00:00 2001
-From: Alexander Kanavin <alex.kanavin@gmail.com>
-Date: Mon, 25 Mar 2019 18:52:48 +0100
-Subject: [PATCH] mesonbuild/environment.py: check environment for various
- binaries
-
-Upstream-Status: Inappropriate [oe-core specific]
-Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
-
----
- mesonbuild/environment.py | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
-index 9a029f4..0cfdf9c 100644
---- a/mesonbuild/environment.py
-+++ b/mesonbuild/environment.py
-@@ -448,7 +448,7 @@ class Environment:
-             config = MesonConfigFile.from_config_parser(
-                 coredata.load_configs(self.coredata.cross_files))
-             properties.host = Properties(config.get('properties', {}), False)
--            binaries.host = BinaryTable(config.get('binaries', {}), False)
-+            binaries.host = BinaryTable(config.get('binaries', {}), True)
-             if 'host_machine' in config:
-                 machines.host = MachineInfo.from_literal(config['host_machine'])
-             if 'target_machine' in config:
diff --git a/poky/meta/recipes-devtools/meson/meson/0002-Support-building-allarch-recipes-again.patch b/poky/meta/recipes-devtools/meson/meson/0002-Support-building-allarch-recipes-again.patch
index d2c3f8c..246c4d7 100644
--- a/poky/meta/recipes-devtools/meson/meson/0002-Support-building-allarch-recipes-again.patch
+++ b/poky/meta/recipes-devtools/meson/meson/0002-Support-building-allarch-recipes-again.patch
@@ -1,4 +1,4 @@
-From 9c221c74bd306dfa6fec22c8f156eb9d4e4f7fcb Mon Sep 17 00:00:00 2001
+From 45df8f0a71c6b60cb98a336f8690af04965dfa9b Mon Sep 17 00:00:00 2001
 From: Peter Kjellerstedt <pkj@axis.com>
 Date: Thu, 26 Jul 2018 16:32:49 +0200
 Subject: [PATCH] Support building allarch recipes again
@@ -13,10 +13,10 @@
  1 file changed, 1 insertion(+)
 
 diff --git a/mesonbuild/envconfig.py b/mesonbuild/envconfig.py
-index 24578ea..216e71f 100644
+index 18bbf86..e76315e 100644
 --- a/mesonbuild/envconfig.py
 +++ b/mesonbuild/envconfig.py
-@@ -36,6 +36,7 @@ _T = typing.TypeVar('_T')
+@@ -36,6 +36,7 @@ _T = T.TypeVar('_T')
 
 
  known_cpu_families = (
diff --git a/poky/meta/recipes-devtools/meson/meson/0002-gobject-introspection-determine-g-ir-scanner-and-g-i.patch b/poky/meta/recipes-devtools/meson/meson/0002-gobject-introspection-determine-g-ir-scanner-and-g-i.patch
deleted file mode 100644
index 61b26bb..0000000
--- a/poky/meta/recipes-devtools/meson/meson/0002-gobject-introspection-determine-g-ir-scanner-and-g-i.patch
+++ /dev/null
@@ -1,40 +0,0 @@
-From 9ccaed380780178c4dab3a681f652ac7cd27452d Mon Sep 17 00:00:00 2001
-From: Alexander Kanavin <alex.kanavin@gmail.com>
-Date: Fri, 4 Aug 2017 16:18:47 +0300
-Subject: [PATCH] gobject-introspection: determine g-ir-scanner and
- g-ir-compiler paths from pkgconfig
-
-Do not hardcode the name of those binaries; gobject-introspection
-provides them via pkgconfig, and they can be set to something else
-(for example when cross-compiling).
-
-Upstream-Status: Pending
-Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
-
----
- mesonbuild/modules/gnome.py | 6 +++---
- 1 file changed, 3 insertions(+), 3 deletions(-)
-
-diff --git a/mesonbuild/modules/gnome.py b/mesonbuild/modules/gnome.py
-index 7c5a363..0002498 100644
---- a/mesonbuild/modules/gnome.py
-+++ b/mesonbuild/modules/gnome.py
-@@ -744,15 +744,15 @@ class GnomeModule(ExtensionModule):
-         if kwargs.get('install_dir'):
-             raise MesonException('install_dir is not supported with generate_gir(), see "install_dir_gir" and "install_dir_typelib"')
- 
--        giscanner = self.interpreter.find_program_impl('g-ir-scanner')
--        gicompiler = self.interpreter.find_program_impl('g-ir-compiler')
--
-         girtargets = [self._unwrap_gir_target(arg, state) for arg in args]
- 
-         if len(girtargets) > 1 and any([isinstance(el, build.Executable) for el in girtargets]):
-             raise MesonException('generate_gir only accepts a single argument when one of the arguments is an executable')
- 
-         self.gir_dep, pkgargs = self._get_gir_dep(state)
-+        giscanner = os.environ['PKG_CONFIG_SYSROOT_DIR'] + self.gir_dep.get_pkgconfig_variable('g_ir_scanner', {})
-+        gicompiler = os.environ['PKG_CONFIG_SYSROOT_DIR'] + self.gir_dep.get_pkgconfig_variable('g_ir_compiler', {})
-+
- 
-         ns = kwargs.pop('namespace')
-         nsversion = kwargs.pop('nsversion')
diff --git a/poky/meta/recipes-devtools/meson/meson/0003-native_bindir.patch b/poky/meta/recipes-devtools/meson/meson/0003-native_bindir.patch
index a5baca0..64e9fae 100644
--- a/poky/meta/recipes-devtools/meson/meson/0003-native_bindir.patch
+++ b/poky/meta/recipes-devtools/meson/meson/0003-native_bindir.patch
@@ -1,4 +1,4 @@
-From e76726321067748362b39937bd1e663a1a948ad5 Mon Sep 17 00:00:00 2001
+From da2091f6dfe978fc6140fc2d01bcafbbfae8d8db Mon Sep 17 00:00:00 2001
 From: Ricardo Ribalda Delgado <ricardo.ribalda@gmail.com>
 Date: Wed, 15 Nov 2017 15:05:01 +0100
 Subject: [PATCH] native_bindir
@@ -22,10 +22,10 @@
  2 files changed, 14 insertions(+), 11 deletions(-)
 
 diff --git a/mesonbuild/dependencies/base.py b/mesonbuild/dependencies/base.py
-index 40e304c..4b687df 100644
+index 50f4179..e1529d8 100644
 --- a/mesonbuild/dependencies/base.py
 +++ b/mesonbuild/dependencies/base.py
-@@ -184,7 +184,7 @@ class Dependency:
+@@ -157,7 +157,7 @@ class Dependency:
      def get_exe_args(self, compiler):
          return []
 
@@ -34,16 +34,16 @@
          raise DependencyException('{!r} is not a pkgconfig dependency'.format(self.name))
 
      def get_configtool_variable(self, variable_name):
-@@ -247,7 +247,7 @@ class InternalDependency(Dependency):
-         self.sources = sources
+@@ -225,7 +225,7 @@ class InternalDependency(Dependency):
          self.ext_deps = ext_deps
+         self.variables = variables
 
 -    def get_pkgconfig_variable(self, variable_name, kwargs):
 +    def get_pkgconfig_variable(self, variable_name, kwargs, use_native=False):
          raise DependencyException('Method "get_pkgconfig_variable()" is '
                                    'invalid for an internal dependency')
 
-@@ -673,15 +673,18 @@ class PkgConfigDependency(ExternalDependency):
+@@ -633,15 +633,18 @@ class PkgConfigDependency(ExternalDependency):
          return s.format(self.__class__.__name__, self.name, self.is_found,
                          self.version_reqs)
 
@@ -65,7 +65,7 @@
          # Always copy the environment since we're going to modify it
          # with pkg-config variables
          if env is None:
-@@ -701,7 +704,7 @@ class PkgConfigDependency(ExternalDependency):
+@@ -667,7 +670,7 @@ class PkgConfigDependency(ExternalDependency):
          targs = tuple(args)
          cache = PkgConfigDependency.pkgbin_cache
          if (self.pkgbin, targs, fenv) not in cache:
@@ -74,7 +74,7 @@
          return cache[(self.pkgbin, targs, fenv)]
 
      def _convert_mingw_paths(self, args: T.List[str]) -> T.List[str]:
-@@ -907,7 +910,7 @@ class PkgConfigDependency(ExternalDependency):
+@@ -876,7 +879,7 @@ class PkgConfigDependency(ExternalDependency):
                                        (self.name, out_raw))
          self.link_args, self.raw_link_args = self._search_libs(out, out_raw)
 
@@ -83,7 +83,7 @@
          options = ['--variable=' + variable_name, self.name]
 
          if 'define_variable' in kwargs:
-@@ -920,7 +923,7 @@ class PkgConfigDependency(ExternalDependency):
+@@ -889,7 +892,7 @@ class PkgConfigDependency(ExternalDependency):
 
              options = ['--define-variable=' + '='.join(definition)] + options
 
@@ -93,10 +93,10 @@
          if ret != 0:
              if self.required:
 diff --git a/mesonbuild/dependencies/ui.py b/mesonbuild/dependencies/ui.py
-index da411ef..856506a 100644
+index 741f0b8..134dd54 100644
 --- a/mesonbuild/dependencies/ui.py
 +++ b/mesonbuild/dependencies/ui.py
-@@ -330,7 +330,7 @@ class QtBaseDependency(ExternalDependency):
+@@ -320,7 +320,7 @@ class QtBaseDependency(ExternalDependency):
          self.bindir = self.get_pkgconfig_host_bins(core)
          if not self.bindir:
              # If exec_prefix is not defined, the pkg-config file is broken
@@ -105,7 +105,7 @@
              if prefix:
                  self.bindir = os.path.join(prefix, 'bin')
 
-@@ -508,7 +508,7 @@ class Qt4Dependency(QtBaseDependency):
+@@ -524,7 +524,7 @@ class Qt4Dependency(QtBaseDependency):
          applications = ['moc', 'uic', 'rcc', 'lupdate', 'lrelease']
          for application in applications:
              try:
@@ -114,7 +114,7 @@
              except MesonException:
                  pass
 
-@@ -518,7 +518,7 @@ class Qt5Dependency(QtBaseDependency):
+@@ -534,7 +534,7 @@ class Qt5Dependency(QtBaseDependency):
          QtBaseDependency.__init__(self, 'qt5', env, kwargs)
 
      def get_pkgconfig_host_bins(self, core):
diff --git a/poky/meta/recipes-devtools/meson/meson/disable-rpath-handling.patch b/poky/meta/recipes-devtools/meson/meson/disable-rpath-handling.patch
index 4b1fb57..38e50d7 100644
--- a/poky/meta/recipes-devtools/meson/meson/disable-rpath-handling.patch
+++ b/poky/meta/recipes-devtools/meson/meson/disable-rpath-handling.patch
@@ -1,4 +1,9 @@
-We need to allow our rpaths generated through the compiler flags to make it into 
+From 3af10fa8cd4e97181288d72227dea712290fd5e6 Mon Sep 17 00:00:00 2001
+From: Richard Purdie <richard.purdie@linuxfoundation.org>
+Date: Fri, 23 Nov 2018 15:28:28 +0000
+Subject: [PATCH] meson: Disable rpath stripping at install time
+
+We need to allow our rpaths generated through the compiler flags to make it into
 our binaries. Therefore disable the meson manipulations of these unless there
 is a specific directive to do something differently in the project.
 
@@ -6,13 +11,17 @@
 
 Upstream-Status: Submitted [https://github.com/mesonbuild/meson/issues/2567]
 
-Index: meson-0.47.2/mesonbuild/minstall.py
-===================================================================
---- meson-0.47.2.orig/mesonbuild/minstall.py
-+++ meson-0.47.2/mesonbuild/minstall.py
-@@ -486,8 +486,11 @@ class Installer:
-                         printed_symlink_error = True
-             if os.path.isfile(outname):
+---
+ mesonbuild/minstall.py | 7 +++++--
+ 1 file changed, 5 insertions(+), 2 deletions(-)
+
+diff --git a/mesonbuild/minstall.py b/mesonbuild/minstall.py
+index ace0569..85bd8df 100644
+--- a/mesonbuild/minstall.py
++++ b/mesonbuild/minstall.py
+@@ -508,8 +508,11 @@ class Installer:
+             if file_copied:
+                 self.did_install_something = True
                  try:
 -                    depfixer.fix_rpath(outname, install_rpath, final_path,
 -                                       install_name_mappings, verbose=False)
diff --git a/poky/meta/recipes-devtools/meson/meson_0.53.2.bb b/poky/meta/recipes-devtools/meson/meson_0.54.2.bb
similarity index 100%
rename from poky/meta/recipes-devtools/meson/meson_0.53.2.bb
rename to poky/meta/recipes-devtools/meson/meson_0.54.2.bb
diff --git a/poky/meta/recipes-devtools/meson/nativesdk-meson_0.53.2.bb b/poky/meta/recipes-devtools/meson/nativesdk-meson_0.54.2.bb
similarity index 100%
rename from poky/meta/recipes-devtools/meson/nativesdk-meson_0.53.2.bb
rename to poky/meta/recipes-devtools/meson/nativesdk-meson_0.54.2.bb
diff --git a/poky/meta/recipes-devtools/patchelf/patchelf/fix-phdrs.patch b/poky/meta/recipes-devtools/patchelf/patchelf/fix-phdrs.patch
new file mode 100644
index 0000000..d087bd7
--- /dev/null
+++ b/poky/meta/recipes-devtools/patchelf/patchelf/fix-phdrs.patch
@@ -0,0 +1,37 @@
+When running patchelf on some existing patchelf'd binaries to change to longer 
+RPATHS, ldd would report the binaries as invalid. The output of objdump -x on 
+those libraryies should show the top of the .dynamic section is getting trashed,
+something like:
+
+0x600000001 0x0000000000429000
+0x335000 0x0000000000335000
+0xc740 0x000000000000c740
+0x1000 0x0000000000009098
+SONAME libglib-2.0.so.0
+
+(which should be RPATH and DT_NEEDED entries)
+
+This was tracked down to the code which injects the PT_LOAD section.
+
+The issue is that if the program headers were previously relocated to the end 
+of the file which was how patchelf operated previously, the relocation code 
+wouldn't work properly on a second run as it now assumes they're located after 
+the elf header. This change forces them back to immediately follow the elf
+header which is where the code has made space for them.
+
+Upstream-Status: Submitted [https://github.com/NixOS/patchelf/pull/202]
+Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
+RP 2020/6/2
+
+Index: git/src/patchelf.cc
+===================================================================
+--- git.orig/src/patchelf.cc
++++ git/src/patchelf.cc
+@@ -762,6 +762,7 @@ void ElfFile<ElfFileParamNames>::rewrite
+     }
+ 
+     /* Add a segment that maps the replaced sections into memory. */
++    wri(hdr->e_phoff, sizeof(Elf_Ehdr));
+     phdrs.resize(rdi(hdr->e_phnum) + 1);
+     wri(hdr->e_phnum, rdi(hdr->e_phnum) + 1);
+     Elf_Phdr & phdr = phdrs[rdi(hdr->e_phnum) - 1];
diff --git a/poky/meta/recipes-devtools/patchelf/patchelf_0.10.bb b/poky/meta/recipes-devtools/patchelf/patchelf_0.10.bb
index d29e094..84e6407 100644
--- a/poky/meta/recipes-devtools/patchelf/patchelf_0.10.bb
+++ b/poky/meta/recipes-devtools/patchelf/patchelf_0.10.bb
@@ -1,6 +1,7 @@
 SRC_URI = "git://github.com/NixOS/patchelf;protocol=https \
            file://handle-read-only-files.patch \
            file://fix-adjusting-startPage.patch \
+           file://fix-phdrs.patch \
            "
 
 LICENSE = "GPLv3"
diff --git a/poky/meta/recipes-devtools/python-numpy/python-numpy.inc b/poky/meta/recipes-devtools/python-numpy/python-numpy.inc
index 0bff979..6a437e7 100644
--- a/poky/meta/recipes-devtools/python-numpy/python-numpy.inc
+++ b/poky/meta/recipes-devtools/python-numpy/python-numpy.inc
@@ -9,8 +9,8 @@
            file://0001-Don-t-search-usr-and-so-on-for-libraries-by-default-.patch \
            file://0001-convert-shebang-from-python-to-python3.patch \
            "
-SRC_URI[md5sum] = "cd631c761f141d382b4e1b31c8232fc0"
-SRC_URI[sha256sum] = "93ee59ec38f3bf8f9a42d5f4301f60e6825a4a6385a145f70badcd2bf2a11134"
+SRC_URI[md5sum] = "70e6c294f8dffa8d630eda1b0d42ae4d"
+SRC_URI[sha256sum] = "e0781ec6627e85f2a618478ee278893343fb8b40577b4c74b2ec15c7a5b8f698"
 
 UPSTREAM_CHECK_URI = "https://github.com/numpy/numpy/releases"
 UPSTREAM_CHECK_REGEX = "(?P<pver>\d+(\.\d+)+)\.tar"
diff --git a/poky/meta/recipes-devtools/python-numpy/python3-numpy_1.18.3.bb b/poky/meta/recipes-devtools/python-numpy/python3-numpy_1.18.4.bb
similarity index 100%
rename from poky/meta/recipes-devtools/python-numpy/python3-numpy_1.18.3.bb
rename to poky/meta/recipes-devtools/python-numpy/python3-numpy_1.18.4.bb
diff --git a/poky/meta/recipes-devtools/python/files/0001-bpo-39503-CVE-2020-8492-Fix-AbstractBasicAuthHandler.patch b/poky/meta/recipes-devtools/python/files/0001-bpo-39503-CVE-2020-8492-Fix-AbstractBasicAuthHandler.patch
deleted file mode 100644
index e16b99b..0000000
--- a/poky/meta/recipes-devtools/python/files/0001-bpo-39503-CVE-2020-8492-Fix-AbstractBasicAuthHandler.patch
+++ /dev/null
@@ -1,248 +0,0 @@
-From 0b297d4ff1c0e4480ad33acae793fbaf4bf015b4 Mon Sep 17 00:00:00 2001
-From: Victor Stinner <vstinner@python.org>
-Date: Thu, 2 Apr 2020 02:52:20 +0200
-Subject: [PATCH] bpo-39503: CVE-2020-8492: Fix AbstractBasicAuthHandler
- (GH-18284)
-
-Upstream-Status: Backport
-(https://github.com/python/cpython/commit/0b297d4ff1c0e4480ad33acae793fbaf4bf015b4)
-
-CVE: CVE-2020-8492
-
-The AbstractBasicAuthHandler class of the urllib.request module uses
-an inefficient regular expression which can be exploited by an
-attacker to cause a denial of service. Fix the regex to prevent the
-catastrophic backtracking. Vulnerability reported by Ben Caller
-and Matt Schwager.
-
-AbstractBasicAuthHandler of urllib.request now parses all
-WWW-Authenticate HTTP headers and accepts multiple challenges per
-header: use the realm of the first Basic challenge.
-
-Co-Authored-By: Serhiy Storchaka <storchaka@gmail.com>
-Signed-off-by: Trevor Gamblin <trevor.gamblin@windriver.com>
----
- Lib/test/test_urllib2.py                      | 90 ++++++++++++-------
- Lib/urllib/request.py                         | 69 ++++++++++----
- .../2020-03-25-16-02-16.bpo-39503.YmMbYn.rst  |  3 +
- .../2020-01-30-16-15-29.bpo-39503.B299Yq.rst  |  5 ++
- 4 files changed, 115 insertions(+), 52 deletions(-)
- create mode 100644 Misc/NEWS.d/next/Library/2020-03-25-16-02-16.bpo-39503.YmMbYn.rst
- create mode 100644 Misc/NEWS.d/next/Security/2020-01-30-16-15-29.bpo-39503.B299Yq.rst
-
-diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py
-index 8abedaac98..e69ac3e213 100644
---- a/Lib/test/test_urllib2.py
-+++ b/Lib/test/test_urllib2.py
-@@ -1446,40 +1446,64 @@ class HandlerTests(unittest.TestCase):
-         bypass = {'exclude_simple': True, 'exceptions': []}
-         self.assertTrue(_proxy_bypass_macosx_sysconf('test', bypass))
- 
--    def test_basic_auth(self, quote_char='"'):
--        opener = OpenerDirector()
--        password_manager = MockPasswordManager()
--        auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager)
--        realm = "ACME Widget Store"
--        http_handler = MockHTTPHandler(
--            401, 'WWW-Authenticate: Basic realm=%s%s%s\r\n\r\n' %
--            (quote_char, realm, quote_char))
--        opener.add_handler(auth_handler)
--        opener.add_handler(http_handler)
--        self._test_basic_auth(opener, auth_handler, "Authorization",
--                              realm, http_handler, password_manager,
--                              "http://acme.example.com/protected",
--                              "http://acme.example.com/protected",
--                              )
--
--    def test_basic_auth_with_single_quoted_realm(self):
--        self.test_basic_auth(quote_char="'")
--
--    def test_basic_auth_with_unquoted_realm(self):
--        opener = OpenerDirector()
--        password_manager = MockPasswordManager()
--        auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager)
--        realm = "ACME Widget Store"
--        http_handler = MockHTTPHandler(
--            401, 'WWW-Authenticate: Basic realm=%s\r\n\r\n' % realm)
--        opener.add_handler(auth_handler)
--        opener.add_handler(http_handler)
--        with self.assertWarns(UserWarning):
-+    def check_basic_auth(self, headers, realm):
-+        with self.subTest(realm=realm, headers=headers):
-+            opener = OpenerDirector()
-+            password_manager = MockPasswordManager()
-+            auth_handler = urllib.request.HTTPBasicAuthHandler(password_manager)
-+            body = '\r\n'.join(headers) + '\r\n\r\n'
-+            http_handler = MockHTTPHandler(401, body)
-+            opener.add_handler(auth_handler)
-+            opener.add_handler(http_handler)
-             self._test_basic_auth(opener, auth_handler, "Authorization",
--                                realm, http_handler, password_manager,
--                                "http://acme.example.com/protected",
--                                "http://acme.example.com/protected",
--                                )
-+                                  realm, http_handler, password_manager,
-+                                  "http://acme.example.com/protected",
-+                                  "http://acme.example.com/protected")
-+
-+    def test_basic_auth(self):
-+        realm = "realm2@example.com"
-+        realm2 = "realm2@example.com"
-+        basic = f'Basic realm="{realm}"'
-+        basic2 = f'Basic realm="{realm2}"'
-+        other_no_realm = 'Otherscheme xxx'
-+        digest = (f'Digest realm="{realm2}", '
-+                  f'qop="auth, auth-int", '
-+                  f'nonce="dcd98b7102dd2f0e8b11d0f600bfb0c093", '
-+                  f'opaque="5ccc069c403ebaf9f0171e9517f40e41"')
-+        for realm_str in (
-+            # test "quote" and 'quote'
-+            f'Basic realm="{realm}"',
-+            f"Basic realm='{realm}'",
-+
-+            # charset is ignored
-+            f'Basic realm="{realm}", charset="UTF-8"',
-+
-+            # Multiple challenges per header
-+            f'{basic}, {basic2}',
-+            f'{basic}, {other_no_realm}',
-+            f'{other_no_realm}, {basic}',
-+            f'{basic}, {digest}',
-+            f'{digest}, {basic}',
-+        ):
-+            headers = [f'WWW-Authenticate: {realm_str}']
-+            self.check_basic_auth(headers, realm)
-+
-+        # no quote: expect a warning
-+        with support.check_warnings(("Basic Auth Realm was unquoted",
-+                                     UserWarning)):
-+            headers = [f'WWW-Authenticate: Basic realm={realm}']
-+            self.check_basic_auth(headers, realm)
-+
-+        # Multiple headers: one challenge per header.
-+        # Use the first Basic realm.
-+        for challenges in (
-+            [basic,  basic2],
-+            [basic,  digest],
-+            [digest, basic],
-+        ):
-+            headers = [f'WWW-Authenticate: {challenge}'
-+                       for challenge in challenges]
-+            self.check_basic_auth(headers, realm)
- 
-     def test_proxy_basic_auth(self):
-         opener = OpenerDirector()
-diff --git a/Lib/urllib/request.py b/Lib/urllib/request.py
-index 7fe50535da..2a3d71554f 100644
---- a/Lib/urllib/request.py
-+++ b/Lib/urllib/request.py
-@@ -937,8 +937,15 @@ class AbstractBasicAuthHandler:
- 
-     # allow for double- and single-quoted realm values
-     # (single quotes are a violation of the RFC, but appear in the wild)
--    rx = re.compile('(?:.*,)*[ \t]*([^ \t]+)[ \t]+'
--                    'realm=(["\']?)([^"\']*)\\2', re.I)
-+    rx = re.compile('(?:^|,)'   # start of the string or ','
-+                    '[ \t]*'    # optional whitespaces
-+                    '([^ \t]+)' # scheme like "Basic"
-+                    '[ \t]+'    # mandatory whitespaces
-+                    # realm=xxx
-+                    # realm='xxx'
-+                    # realm="xxx"
-+                    'realm=(["\']?)([^"\']*)\\2',
-+                    re.I)
- 
-     # XXX could pre-emptively send auth info already accepted (RFC 2617,
-     # end of section 2, and section 1.2 immediately after "credentials"
-@@ -950,27 +957,51 @@ class AbstractBasicAuthHandler:
-         self.passwd = password_mgr
-         self.add_password = self.passwd.add_password
- 
-+    def _parse_realm(self, header):
-+        # parse WWW-Authenticate header: accept multiple challenges per header
-+        found_challenge = False
-+        for mo in AbstractBasicAuthHandler.rx.finditer(header):
-+            scheme, quote, realm = mo.groups()
-+            if quote not in ['"', "'"]:
-+                warnings.warn("Basic Auth Realm was unquoted",
-+                              UserWarning, 3)
-+
-+            yield (scheme, realm)
-+
-+            found_challenge = True
-+
-+        if not found_challenge:
-+            if header:
-+                scheme = header.split()[0]
-+            else:
-+                scheme = ''
-+            yield (scheme, None)
-+
-     def http_error_auth_reqed(self, authreq, host, req, headers):
-         # host may be an authority (without userinfo) or a URL with an
-         # authority
--        # XXX could be multiple headers
--        authreq = headers.get(authreq, None)
-+        headers = headers.get_all(authreq)
-+        if not headers:
-+            # no header found
-+            return
- 
--        if authreq:
--            scheme = authreq.split()[0]
--            if scheme.lower() != 'basic':
--                raise ValueError("AbstractBasicAuthHandler does not"
--                                 " support the following scheme: '%s'" %
--                                 scheme)
--            else:
--                mo = AbstractBasicAuthHandler.rx.search(authreq)
--                if mo:
--                    scheme, quote, realm = mo.groups()
--                    if quote not in ['"',"'"]:
--                        warnings.warn("Basic Auth Realm was unquoted",
--                                      UserWarning, 2)
--                    if scheme.lower() == 'basic':
--                        return self.retry_http_basic_auth(host, req, realm)
-+        unsupported = None
-+        for header in headers:
-+            for scheme, realm in self._parse_realm(header):
-+                if scheme.lower() != 'basic':
-+                    unsupported = scheme
-+                    continue
-+
-+                if realm is not None:
-+                    # Use the first matching Basic challenge.
-+                    # Ignore following challenges even if they use the Basic
-+                    # scheme.
-+                    return self.retry_http_basic_auth(host, req, realm)
-+
-+        if unsupported is not None:
-+            raise ValueError("AbstractBasicAuthHandler does not "
-+                             "support the following scheme: %r"
-+                             % (scheme,))
- 
-     def retry_http_basic_auth(self, host, req, realm):
-         user, pw = self.passwd.find_user_password(realm, host)
-diff --git a/Misc/NEWS.d/next/Library/2020-03-25-16-02-16.bpo-39503.YmMbYn.rst b/Misc/NEWS.d/next/Library/2020-03-25-16-02-16.bpo-39503.YmMbYn.rst
-new file mode 100644
-index 0000000000..be80ce79d9
---- /dev/null
-+++ b/Misc/NEWS.d/next/Library/2020-03-25-16-02-16.bpo-39503.YmMbYn.rst
-@@ -0,0 +1,3 @@
-+:class:`~urllib.request.AbstractBasicAuthHandler` of :mod:`urllib.request`
-+now parses all WWW-Authenticate HTTP headers and accepts multiple challenges
-+per header: use the realm of the first Basic challenge.
-diff --git a/Misc/NEWS.d/next/Security/2020-01-30-16-15-29.bpo-39503.B299Yq.rst b/Misc/NEWS.d/next/Security/2020-01-30-16-15-29.bpo-39503.B299Yq.rst
-new file mode 100644
-index 0000000000..9f2800581c
---- /dev/null
-+++ b/Misc/NEWS.d/next/Security/2020-01-30-16-15-29.bpo-39503.B299Yq.rst
-@@ -0,0 +1,5 @@
-+CVE-2020-8492: The :class:`~urllib.request.AbstractBasicAuthHandler` class of the
-+:mod:`urllib.request` module uses an inefficient regular expression which can
-+be exploited by an attacker to cause a denial of service. Fix the regex to
-+prevent the catastrophic backtracking. Vulnerability reported by Ben Caller
-+and Matt Schwager.
--- 
-2.24.1
-
diff --git a/poky/meta/recipes-devtools/python/python-cython.inc b/poky/meta/recipes-devtools/python/python-cython.inc
index 437e796..eee567e 100644
--- a/poky/meta/recipes-devtools/python/python-cython.inc
+++ b/poky/meta/recipes-devtools/python/python-cython.inc
@@ -7,8 +7,7 @@
 PYPI_PACKAGE = "Cython"
 BBCLASSEXTEND = "native nativesdk"
 
-SRC_URI[md5sum] = "a899abaa48b68bb679aef45ceb4b89d3"
-SRC_URI[sha256sum] = "232755284f942cbb3b43a06cd85974ef3c970a021aef19b5243c03ee2b08fa05"
+SRC_URI[sha256sum] = "97f98a7dc0d58ea833dc1f8f8b3ce07adf4c0f030d1886c5399a2135ed415258"
 UPSTREAM_CHECK_REGEX = "Cython-(?P<pver>.*)\.tar"
 
 inherit pypi
diff --git a/poky/meta/recipes-devtools/python/python-gitdb.inc b/poky/meta/recipes-devtools/python/python-gitdb.inc
index a91bb32..618d85f 100644
--- a/poky/meta/recipes-devtools/python/python-gitdb.inc
+++ b/poky/meta/recipes-devtools/python/python-gitdb.inc
@@ -8,7 +8,7 @@
 
 PYPI_PACKAGE = "gitdb"
 
-SRC_URI[sha256sum] = "6f0ecd46f99bb4874e5678d628c3a198e2b4ef38daea2756a2bfd8df7dd5c1a5"
+SRC_URI[sha256sum] = "c9e1f2d0db7ddb9a704c2a0217be31214e91a4fe1dea1efad19ae42ba0c285c9"
 
 DEPENDS = "${PYTHON_PN}-async ${PYTHON_PN}-setuptools-native ${PYTHON_PN}-smmap"
 
diff --git a/poky/meta/recipes-devtools/python/python-setuptools.inc b/poky/meta/recipes-devtools/python/python-setuptools.inc
index e9ad93d..c91cca9 100644
--- a/poky/meta/recipes-devtools/python/python-setuptools.inc
+++ b/poky/meta/recipes-devtools/python/python-setuptools.inc
@@ -12,8 +12,8 @@
 
 SRC_URI += "file://0001-change-shebang-to-python3.patch"
 
-SRC_URI[md5sum] = "0c956eea142af9c2b02d72e3c042af30"
-SRC_URI[sha256sum] = "89c6e6011ec2f6d57d43a3f9296c4ef022c2cbf49bab26b407fe67992ae3397f"
+SRC_URI[md5sum] = "6e9de90b242fdd60ef59f497424ce13a"
+SRC_URI[sha256sum] = "145fa62b9d7bb544fce16e9b5a9bf4ab2032d2f758b7cd674af09a92736aff74"
 
 DEPENDS += "${PYTHON_PN}"
 
diff --git a/poky/meta/recipes-devtools/python/python-smmap.inc b/poky/meta/recipes-devtools/python/python-smmap.inc
index b878b4b..7703722 100644
--- a/poky/meta/recipes-devtools/python/python-smmap.inc
+++ b/poky/meta/recipes-devtools/python/python-smmap.inc
@@ -9,10 +9,9 @@
 
 inherit pypi
 
-PYPI_PACKAGE = "smmap2"
+PYPI_PACKAGE = "smmap"
 
-SRC_URI[md5sum] = "1c59a985be5aa645c4c5a4e063a40dd5"
-SRC_URI[sha256sum] = "29a9ffa0497e7f2be94ca0ed1ca1aa3cd4cf25a1f6b4f5f87f74b46ed91d609a"
+SRC_URI[sha256sum] = "9c98bbd1f9786d22f14b3d4126894d56befb835ec90cef151af566c7e19b5d24"
 
 RDEPENDS_${PN} += "${PYTHON_PN}-codecs \
                    ${PYTHON_PN}-mmap \
diff --git a/poky/meta/recipes-devtools/python/python-subunit.inc b/poky/meta/recipes-devtools/python/python-subunit.inc
index afaaa51..fc63b38 100644
--- a/poky/meta/recipes-devtools/python/python-subunit.inc
+++ b/poky/meta/recipes-devtools/python/python-subunit.inc
@@ -6,8 +6,8 @@
 
 PYPI_PACKAGE = "python-subunit"
 
-SRC_URI[md5sum] = "16d468a3aeafe6c60a0c3b2b9132d65b"
-SRC_URI[sha256sum] = "9607edbee4c1e5a30ff88549ce8d9feb0b9bcbcb5e55033a9d76e86075465cbb"
+SRC_URI[md5sum] = "30f1ab20651d94442dd9a7f8c9e8d633"
+SRC_URI[sha256sum] = "042039928120fbf392e8c983d60f3d8ae1b88f90a9f8fd7188ddd9c26cad1e48"
 
 inherit pypi
 
diff --git a/poky/meta/recipes-devtools/python/python-testtools.inc b/poky/meta/recipes-devtools/python/python-testtools.inc
index d0b2e46..f1f1e26 100644
--- a/poky/meta/recipes-devtools/python/python-testtools.inc
+++ b/poky/meta/recipes-devtools/python/python-testtools.inc
@@ -6,8 +6,8 @@
 
 inherit pypi
 
-SRC_URI[md5sum] = "0f0feb915497816cb99e39437494217e"
-SRC_URI[sha256sum] = "5827ec6cf8233e0f29f51025addd713ca010061204fdea77484a2934690a0559"
+SRC_URI[md5sum] = "e8fc7185b47cfb908c641f8c4b2a6add"
+SRC_URI[sha256sum] = "64c974a6cca4385d05f4bbfa2deca1c39ce88ede31c3448bee86a7259a9a61c8"
 
 DEPENDS += " \
     ${PYTHON_PN}-pbr \
diff --git a/poky/meta/recipes-devtools/python/python3-cython_0.29.16.bb b/poky/meta/recipes-devtools/python/python3-cython_0.29.19.bb
similarity index 100%
rename from poky/meta/recipes-devtools/python/python3-cython_0.29.16.bb
rename to poky/meta/recipes-devtools/python/python3-cython_0.29.19.bb
diff --git a/poky/meta/recipes-devtools/python/python3-gitdb_4.0.4.bb b/poky/meta/recipes-devtools/python/python3-gitdb_4.0.4.bb
deleted file mode 100644
index 2dcd9c8..0000000
--- a/poky/meta/recipes-devtools/python/python3-gitdb_4.0.4.bb
+++ /dev/null
@@ -1,3 +0,0 @@
-inherit setuptools3
-require python-gitdb.inc
-
diff --git a/poky/meta/recipes-devtools/python/python3-gitdb_4.0.5.bb b/poky/meta/recipes-devtools/python/python3-gitdb_4.0.5.bb
new file mode 100644
index 0000000..fe56bf9
--- /dev/null
+++ b/poky/meta/recipes-devtools/python/python3-gitdb_4.0.5.bb
@@ -0,0 +1,4 @@
+inherit setuptools3
+require python-gitdb.inc
+
+SRC_URI[md5sum] = "0e2d3f34efece5deda7c55fede6507cc"
diff --git a/poky/meta/recipes-devtools/python/python3-mako_1.1.1.bb b/poky/meta/recipes-devtools/python/python3-mako_1.1.3.bb
similarity index 75%
rename from poky/meta/recipes-devtools/python/python3-mako_1.1.1.bb
rename to poky/meta/recipes-devtools/python/python3-mako_1.1.3.bb
index bc38009..cda4e99 100644
--- a/poky/meta/recipes-devtools/python/python3-mako_1.1.1.bb
+++ b/poky/meta/recipes-devtools/python/python3-mako_1.1.3.bb
@@ -8,8 +8,7 @@
 
 inherit pypi setuptools3
 
-SRC_URI[md5sum] = "2660a4916f2f63456e6885c727b7cd2f"
-SRC_URI[sha256sum] = "2984a6733e1d472796ceef37ad48c26f4a984bb18119bb2dbc37a44d8f6e75a4"
+SRC_URI[sha256sum] = "8195c8c1400ceb53496064314c6736719c6f25e7479cd24c77be3d9361cddc27"
 
 RDEPENDS_${PN} = "${PYTHON_PN}-html \
                   ${PYTHON_PN}-netclient \
diff --git a/poky/meta/recipes-devtools/python/python3-pycairo_1.19.0.bb b/poky/meta/recipes-devtools/python/python3-pycairo_1.19.1.bb
similarity index 84%
rename from poky/meta/recipes-devtools/python/python3-pycairo_1.19.0.bb
rename to poky/meta/recipes-devtools/python/python3-pycairo_1.19.1.bb
index 8f60834..34c8543 100644
--- a/poky/meta/recipes-devtools/python/python3-pycairo_1.19.0.bb
+++ b/poky/meta/recipes-devtools/python/python3-pycairo_1.19.1.bb
@@ -13,8 +13,8 @@
 SRC_URI = "https://github.com/pygobject/pycairo/releases/download/v${PV}/pycairo-${PV}.tar.gz"
 UPSTREAM_CHECK_URI = "https://github.com/pygobject/pycairo/releases/"
 
-SRC_URI[md5sum] = "38b84416021640b01250c8f8ec4c52d4"
-SRC_URI[sha256sum] = "4f5ba9374a46c98729dd3727d993f5e17ed0286fd6738ed464fe4efa0612d19c"
+SRC_URI[md5sum] = "59bc5c5d1debc3af0f6791af9d612551"
+SRC_URI[sha256sum] = "2c143183280feb67f5beb4e543fd49990c28e7df427301ede04fc550d3562e84"
 
 S = "${WORKDIR}/pycairo-${PV}"
 
diff --git a/poky/meta/recipes-devtools/python/python3-pygments_2.5.2.bb b/poky/meta/recipes-devtools/python/python3-pygments_2.6.1.bb
similarity index 75%
rename from poky/meta/recipes-devtools/python/python3-pygments_2.5.2.bb
rename to poky/meta/recipes-devtools/python/python3-pygments_2.6.1.bb
index 474b954..bffef59 100644
--- a/poky/meta/recipes-devtools/python/python3-pygments_2.5.2.bb
+++ b/poky/meta/recipes-devtools/python/python3-pygments_2.6.1.bb
@@ -5,8 +5,8 @@
 LIC_FILES_CHKSUM = "file://LICENSE;md5=e1d7b7bffbfeaa14083fd2bd3236aea8"
 
 inherit setuptools3
-SRC_URI[md5sum] = "465a35559863089d959d783a69f79b9f"
-SRC_URI[sha256sum] = "98c8aa5a9f778fcd1026a17361ddaf7330d1b7c62ae97c3bb0ae73e0b9b6b0fe"
+SRC_URI[md5sum] = "a48c5219de92f12c41acba814730b31a"
+SRC_URI[sha256sum] = "647344a061c249a3b74e230c739f434d7ea4d8b1d5f3721bc0f3558049b38f44"
 
 DEPENDS += "\
             ${PYTHON_PN} \
diff --git a/poky/meta/recipes-devtools/python/python3-pygobject_3.34.0.bb b/poky/meta/recipes-devtools/python/python3-pygobject_3.36.1.bb
similarity index 87%
rename from poky/meta/recipes-devtools/python/python3-pygobject_3.34.0.bb
rename to poky/meta/recipes-devtools/python/python3-pygobject_3.36.1.bb
index 6babf0c..0a34d43 100644
--- a/poky/meta/recipes-devtools/python/python3-pygobject_3.34.0.bb
+++ b/poky/meta/recipes-devtools/python/python3-pygobject_3.36.1.bb
@@ -14,8 +14,8 @@
     http://ftp.gnome.org/pub/GNOME/sources/${SRCNAME}/${@gnome_verdir("${PV}")}/${SRCNAME}-${PV}.tar.xz \
     file://0001-Do-not-build-tests.patch \
 "
-SRC_URI[md5sum] = "ca1dc4f31c1d6d283758e8f315a88ab6"
-SRC_URI[sha256sum] = "87e2c9aa785f352ef111dcc5f63df9b85cf6e05e52ff04f803ffbebdacf5271a"
+SRC_URI[md5sum] = "ebfebc4533856572281add29f08412bf"
+SRC_URI[sha256sum] = "d1bf42802d1cec113b5adaa0e7bf7f3745b44521dc2163588d276d5cd61d718f"
 
 UNKNOWN_CONFIGURE_WHITELIST = "introspection"
 
diff --git a/poky/meta/recipes-devtools/python/python3-setuptools/0001-change-shebang-to-python3.patch b/poky/meta/recipes-devtools/python/python3-setuptools/0001-change-shebang-to-python3.patch
index 33af8da..6dcf527 100644
--- a/poky/meta/recipes-devtools/python/python3-setuptools/0001-change-shebang-to-python3.patch
+++ b/poky/meta/recipes-devtools/python/python3-setuptools/0001-change-shebang-to-python3.patch
@@ -8,8 +8,7 @@
 Signed-off-by: Changqing Li <changqing.li@windriver.com>
 ---
  pkg_resources/_vendor/appdirs.py   | 2 +-
- setuptools/command/easy_install.py | 2 +-
- 2 files changed, 2 insertions(+), 2 deletions(-)
+ 1 files changed, 1 insertions(+), 1 deletions(-)
 
 diff --git a/pkg_resources/_vendor/appdirs.py b/pkg_resources/_vendor/appdirs.py
 index ae67001..933e398 100644
@@ -21,16 +20,6 @@
  # -*- coding: utf-8 -*-
  # Copyright (c) 2005-2010 ActiveState Software Inc.
  # Copyright (c) 2013 Eddy Petrișor
-diff --git a/setuptools/command/easy_install.py b/setuptools/command/easy_install.py
-index abca1ae..6bcdc98 100644
---- a/setuptools/command/easy_install.py
-+++ b/setuptools/command/easy_install.py
-@@ -1,4 +1,4 @@
--#!/usr/bin/env python
-+#!/usr/bin/env python3
- """
- Easy Install
- ------------
 -- 
 2.24.1
 
diff --git a/poky/meta/recipes-devtools/python/python3-setuptools_45.2.0.bb b/poky/meta/recipes-devtools/python/python3-setuptools_47.1.1.bb
similarity index 100%
rename from poky/meta/recipes-devtools/python/python3-setuptools_45.2.0.bb
rename to poky/meta/recipes-devtools/python/python3-setuptools_47.1.1.bb
diff --git a/poky/meta/recipes-devtools/python/python3-six_1.14.0.bb b/poky/meta/recipes-devtools/python/python3-six_1.14.0.bb
deleted file mode 100644
index 151c366..0000000
--- a/poky/meta/recipes-devtools/python/python3-six_1.14.0.bb
+++ /dev/null
@@ -1,5 +0,0 @@
-inherit setuptools3
-require python-six.inc
-
-SRC_URI[md5sum] = "21674588a57e649d1a6d977ec3122140"
-SRC_URI[sha256sum] = "236bdbdce46e6e6a3d61a337c0f8b763ca1e8717c03b369e87a7ec7ce1319c0a"
diff --git a/poky/meta/recipes-devtools/python/python3-six_1.15.0.bb b/poky/meta/recipes-devtools/python/python3-six_1.15.0.bb
new file mode 100644
index 0000000..6c6f3f9
--- /dev/null
+++ b/poky/meta/recipes-devtools/python/python3-six_1.15.0.bb
@@ -0,0 +1,5 @@
+inherit setuptools3
+require python-six.inc
+
+SRC_URI[md5sum] = "9f90a0eaa0ea7747fda01ca79d21ebcb"
+SRC_URI[sha256sum] = "30639c035cdb23534cd4aa2dd52c3bf48f06e5f4a941509c8bafd8ce11080259"
diff --git a/poky/meta/recipes-devtools/python/python3-smmap_2.0.5.bb b/poky/meta/recipes-devtools/python/python3-smmap_3.0.4.bb
similarity index 97%
rename from poky/meta/recipes-devtools/python/python3-smmap_2.0.5.bb
rename to poky/meta/recipes-devtools/python/python3-smmap_3.0.4.bb
index e87b8df8..5f0f341 100644
--- a/poky/meta/recipes-devtools/python/python3-smmap_2.0.5.bb
+++ b/poky/meta/recipes-devtools/python/python3-smmap_3.0.4.bb
@@ -1,2 +1,3 @@
 inherit setuptools3
 require python-smmap.inc
+
diff --git a/poky/meta/recipes-devtools/python/python3-subunit_1.3.0.bb b/poky/meta/recipes-devtools/python/python3-subunit_1.4.0.bb
similarity index 100%
rename from poky/meta/recipes-devtools/python/python3-subunit_1.3.0.bb
rename to poky/meta/recipes-devtools/python/python3-subunit_1.4.0.bb
diff --git a/poky/meta/recipes-devtools/python/python3-testtools_2.3.0.bb b/poky/meta/recipes-devtools/python/python3-testtools_2.4.0.bb
similarity index 100%
rename from poky/meta/recipes-devtools/python/python3-testtools_2.3.0.bb
rename to poky/meta/recipes-devtools/python/python3-testtools_2.4.0.bb
diff --git a/poky/meta/recipes-devtools/python/python3/0001-Don-t-search-system-for-headers-libraries.patch b/poky/meta/recipes-devtools/python/python3/0001-Don-t-search-system-for-headers-libraries.patch
index acf8e1e..3e471b9 100644
--- a/poky/meta/recipes-devtools/python/python3/0001-Don-t-search-system-for-headers-libraries.patch
+++ b/poky/meta/recipes-devtools/python/python3/0001-Don-t-search-system-for-headers-libraries.patch
@@ -1,16 +1,17 @@
-From 85e8f86ad2b7dec0848cd55b8e810a5e2722b20a Mon Sep 17 00:00:00 2001
+From b880e78bf4a1852e260188e6df3ec6034403d2fc Mon Sep 17 00:00:00 2001
 From: Jeremy Puhlman <jpuhlman@mvista.com>
 Date: Wed, 4 Mar 2020 00:06:42 +0000
 Subject: [PATCH] Don't search system for headers/libraries
 
 Upstream-Status: Inappropriate [oe-core specific]
 Signed-off-by: Jeremy Puhlman <jpuhlman@mvista.com>
+
 ---
  setup.py | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)
 
 diff --git a/setup.py b/setup.py
-index 9da1b3a..59782c0 100644
+index 7208cd0..c0bd0ad 100644
 --- a/setup.py
 +++ b/setup.py
 @@ -674,8 +674,8 @@ class PyBuildExt(build_ext):
@@ -24,6 +25,3 @@
          # lib_dirs and inc_dirs are used to search for files;
          # if a file is found in one of those directories, it can
          # be assumed that no additional -I,-L directives are needed.
--- 
-2.24.1
-
diff --git a/poky/meta/recipes-devtools/python/python3/0001-distutils-sysconfig-append-STAGING_LIBDIR-python-sys.patch b/poky/meta/recipes-devtools/python/python3/0001-distutils-sysconfig-append-STAGING_LIBDIR-python-sys.patch
index e7af3c6..2b68c0a 100644
--- a/poky/meta/recipes-devtools/python/python3/0001-distutils-sysconfig-append-STAGING_LIBDIR-python-sys.patch
+++ b/poky/meta/recipes-devtools/python/python3/0001-distutils-sysconfig-append-STAGING_LIBDIR-python-sys.patch
@@ -1,4 +1,4 @@
-From 7ada9c749f6beb51c13a3debc850755e911548a6 Mon Sep 17 00:00:00 2001
+From bc59d49efff41051034d7fbf5d0c8505e4c3134b Mon Sep 17 00:00:00 2001
 From: Alexander Kanavin <alex.kanavin@gmail.com>
 Date: Thu, 31 Jan 2019 16:46:30 +0100
 Subject: [PATCH] distutils/sysconfig: append
diff --git a/poky/meta/recipes-devtools/python/python3/12-distutils-prefix-is-inside-staging-area.patch b/poky/meta/recipes-devtools/python/python3/12-distutils-prefix-is-inside-staging-area.patch
index 61ac3e7..820fb98 100644
--- a/poky/meta/recipes-devtools/python/python3/12-distutils-prefix-is-inside-staging-area.patch
+++ b/poky/meta/recipes-devtools/python/python3/12-distutils-prefix-is-inside-staging-area.patch
@@ -1,4 +1,4 @@
-From 251347fc970a397a9cd63ed3f87c5e6c52e15187 Mon Sep 17 00:00:00 2001
+From 064187668fcbefdd39a8cde372bf651124c3e578 Mon Sep 17 00:00:00 2001
 From: Khem Raj <raj.khem@gmail.com>
 Date: Tue, 14 May 2013 15:00:26 -0700
 Subject: [PATCH] python3: Add target and native recipes
diff --git a/poky/meta/recipes-devtools/python/python3_3.8.2.bb b/poky/meta/recipes-devtools/python/python3_3.8.3.bb
similarity index 98%
rename from poky/meta/recipes-devtools/python/python3_3.8.2.bb
rename to poky/meta/recipes-devtools/python/python3_3.8.3.bb
index 0474f07..4367923 100644
--- a/poky/meta/recipes-devtools/python/python3_3.8.2.bb
+++ b/poky/meta/recipes-devtools/python/python3_3.8.3.bb
@@ -32,7 +32,6 @@
            file://0001-configure.ac-fix-LIBPL.patch \
            file://0001-python3-Do-not-hardcode-lib-for-distutils.patch \
            file://0020-configure.ac-setup.py-do-not-add-a-curses-include-pa.patch \
-           file://0001-bpo-39503-CVE-2020-8492-Fix-AbstractBasicAuthHandler.patch \
            "
 
 SRC_URI_append_class-native = " \
@@ -41,8 +40,8 @@
            file://0001-Don-t-search-system-for-headers-libraries.patch \
            "
 
-SRC_URI[md5sum] = "e9d6ebc92183a177b8e8a58cad5b8d67"
-SRC_URI[sha256sum] = "2646e7dc233362f59714c6193017bb2d6f7b38d6ab4a0cb5fbac5c36c4d845df"
+SRC_URI[md5sum] = "3000cf50aaa413052aef82fd2122ca78"
+SRC_URI[sha256sum] = "dfab5ec723c218082fe3d5d7ae17ecbdebffa9a1aea4d64aa3a2ecdd2e795864"
 
 # exclude pre-releases for both python 2.x and 3.x
 UPSTREAM_CHECK_REGEX = "[Pp]ython-(?P<pver>\d+(\.\d+)+).tar"
diff --git a/poky/meta/recipes-devtools/rpm/files/0001-Bump-up-the-limit-of-signature-header-to-64MB.patch b/poky/meta/recipes-devtools/rpm/files/0001-Bump-up-the-limit-of-signature-header-to-64MB.patch
new file mode 100644
index 0000000..0a19c12
--- /dev/null
+++ b/poky/meta/recipes-devtools/rpm/files/0001-Bump-up-the-limit-of-signature-header-to-64MB.patch
@@ -0,0 +1,62 @@
+From e8bf0eba7143abb6e69db82ee747a0c6790dd00a Mon Sep 17 00:00:00 2001
+From: Hongxu Jia <hongxu.jia@windriver.com>
+Date: Wed, 3 Jun 2020 10:25:24 +0800
+Subject: [PATCH] Bump up the limit of signature header to 64MB
+
+Since commits [Place file signatures into the signature header where they
+belong][1] applied, run `rpm -Kv **.rpm' failed if signature header
+is larger than 64KB. Here are steps:
+
+1) A unsigned rpm package, the size is 227560 bytes
+$ ls -al xz-src-5.2.5-r0.corei7_64.rpm
+-rw-------. 1 mockbuild 1000 227560 Jun  3 09:59
+
+2) Sign the rpm package
+$ rpmsign --addsign ... xz-src-5.2.5-r0.corei7_64.rpm
+
+3) The size of signed rpm is 312208 bytes
+$ ls -al xz-src-5.2.5-r0.corei7_64.rpm
+-rw-------. 1 mockbuild 1000 312208 Jun  3 09:48
+
+4) Run `rpm -Kv' failed with signature hdr data out of range
+$ rpm -Kv xz-src-5.2.5-r0.corei7_64.rpm
+xz-src-5.2.5-r0.corei7_64.rpm:
+error: xz-src-5.2.5-r0.corei7_64.rpm: signature hdr data: BAD, no. of
+bytes(88864) out of range
+
+From 1) and 3), the size of signed rpm package increased
+312208 - 227560 = 84648, so the check of dl_max (64KB,65536)
+is not enough.
+
+As [1] said:
+
+    This also means the signature header can be MUCH bigger than ever
+    before,so bump up the limit (to 64MB, arbitrary something for now)
+
+So [1] missed to multiply by 1024.
+
+[1] https://github.com/rpm-software-management/rpm/commit/f558e886050c4e98f6cdde391df679a411b3f62c
+
+Upstream-Status: Backport [https://github.com/rpm-software-management/rpm/commit/486579912381ede82172dc6d0ff3941a6d0536b5]
+
+Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
+---
+ lib/header.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/lib/header.c b/lib/header.c
+index 9ec7ed0..cbf6890 100644
+--- a/lib/header.c
++++ b/lib/header.c
+@@ -1906,7 +1906,7 @@ rpmRC hdrblobRead(FD_t fd, int magic, int exact_size, rpmTagVal regionTag, hdrbl
+ 
+     if (regionTag == RPMTAG_HEADERSIGNATURES) {
+ 	il_max = 32;
+-	dl_max = 64 * 1024;
++	dl_max = 64 * 1024 * 1024;
+     }
+ 
+     memset(block, 0, sizeof(block));
+-- 
+2.25.4
+
diff --git a/poky/meta/recipes-devtools/rpm/rpm_4.15.1.bb b/poky/meta/recipes-devtools/rpm/rpm_4.15.1.bb
index 8add142..cbe1acf 100644
--- a/poky/meta/recipes-devtools/rpm/rpm_4.15.1.bb
+++ b/poky/meta/recipes-devtools/rpm/rpm_4.15.1.bb
@@ -40,6 +40,7 @@
            file://0001-rpmplugins.c-call-dlerror-prior-to-dlsym.patch \
            file://0001-rpmfc.c-do-not-run-file-classification-in-parallel.patch \
            file://0001-lib-transaction.c-fix-file-conflicts-for-MIPS64-N32.patch \
+           file://0001-Bump-up-the-limit-of-signature-header-to-64MB.patch \
            "
 
 PE = "1"
diff --git a/poky/meta/recipes-devtools/strace/strace_5.5.bb b/poky/meta/recipes-devtools/strace/strace_5.6.bb
similarity index 89%
rename from poky/meta/recipes-devtools/strace/strace_5.5.bb
rename to poky/meta/recipes-devtools/strace/strace_5.6.bb
index ae552da..53679cd 100644
--- a/poky/meta/recipes-devtools/strace/strace_5.5.bb
+++ b/poky/meta/recipes-devtools/strace/strace_5.6.bb
@@ -15,8 +15,8 @@
            file://uintptr_t.patch \
            file://0001-strace-fix-reproducibilty-issues.patch \
            "
-SRC_URI[md5sum] = "dbce2e84632b39a4ed86b9fc60447af9"
-SRC_URI[sha256sum] = "9f58958c8e59ea62293d907d10572e352b582bd7948ed21aa28ebb47e5bf30ff"
+SRC_URI[md5sum] = "f8e0394d4e537b3faadf0a72f5d1d17e"
+SRC_URI[sha256sum] = "189968eeae06ed9e20166ec55a830943c84374676a457c9fe010edc7541f1b01"
 
 inherit autotools ptest
 
@@ -27,7 +27,7 @@
 PACKAGECONFIG[bluez] = "ac_cv_header_bluetooth_bluetooth_h=yes,ac_cv_header_bluetooth_bluetooth_h=no,bluez5"
 PACKAGECONFIG[libunwind] = "--with-libunwind,--without-libunwind,libunwind"
 
-EXTRA_OECONF += "--enable-mpers=no"
+EXTRA_OECONF += "--enable-mpers=no --disable-gcc-Werror"
 
 CFLAGS_append_libc-musl = " -Dsigcontext_struct=sigcontext"
 
diff --git a/poky/meta/recipes-devtools/vala/vala_0.46.6.bb b/poky/meta/recipes-devtools/vala/vala_0.46.6.bb
deleted file mode 100644
index 66f6203..0000000
--- a/poky/meta/recipes-devtools/vala/vala_0.46.6.bb
+++ /dev/null
@@ -1,8 +0,0 @@
-require ${BPN}.inc
-
-SRC_URI += "file://0001-git-version-gen-don-t-append-dirty-if-we-re-not-in-g.patch \
-           file://0001-vapigen.m4-use-PKG_CONFIG_SYSROOT_DIR.patch \
-           "
-
-SRC_URI[md5sum] = "d9af125648505503b139ebc2d2c9eee5"
-SRC_URI[sha256sum] = "ef31649932872f094971d46453b21c60a41661670f98afa334062425b4aec47a"
diff --git a/poky/meta/recipes-devtools/vala/vala_0.48.6.bb b/poky/meta/recipes-devtools/vala/vala_0.48.6.bb
new file mode 100644
index 0000000..9dace13
--- /dev/null
+++ b/poky/meta/recipes-devtools/vala/vala_0.48.6.bb
@@ -0,0 +1,7 @@
+require ${BPN}.inc
+
+SRC_URI += "file://0001-git-version-gen-don-t-append-dirty-if-we-re-not-in-g.patch \
+           file://0001-vapigen.m4-use-PKG_CONFIG_SYSROOT_DIR.patch \
+           "
+
+SRC_URI[sha256sum] = "d18d08ed030ce0e0f044f4c15c9df3c25b15beaf8700e45e43b736a6debf9707"
diff --git a/poky/meta/recipes-devtools/valgrind/valgrind/0001-gcc10-arm64-build-needs-__getauxval-for-linking-with.patch b/poky/meta/recipes-devtools/valgrind/valgrind/0001-gcc10-arm64-build-needs-__getauxval-for-linking-with.patch
deleted file mode 100644
index 9afa7f6..0000000
--- a/poky/meta/recipes-devtools/valgrind/valgrind/0001-gcc10-arm64-build-needs-__getauxval-for-linking-with.patch
+++ /dev/null
@@ -1,144 +0,0 @@
-From abbc0761fa0349d49b10dc8c0f10af6bc0578c40 Mon Sep 17 00:00:00 2001
-From: Mark Wielaard <mark@klomp.org>
-Date: Tue, 12 May 2020 16:58:36 +0200
-Subject: [PATCH 1/2] gcc10 arm64 build needs __getauxval for linking with
- libgcc
-
-Provide a new library libgcc-sup-<platform>.a that contains symbols
-needed by libgcc. This needs to be linked after -lgcc to provide
-any symbols missing which would normally be provided by glibc.
-At the moment this only provides __getauxval on arm64 linux.
-
-https://bugs.kde.org/show_bug.cgi?id=421321
-
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
-Upstream-Status: Backport [https://sourceware.org/git/?p=valgrind.git;a=commit;h=abbc0761fa0349d49b10dc8c0f10af6bc0578c40]
-
----
- Makefile.tool.am         |  3 +-
- coregrind/Makefile.am    | 26 +++++++++++++++++
- coregrind/m_libgcc_sup.c | 61 ++++++++++++++++++++++++++++++++++++++++
- 3 files changed, 89 insertions(+), 1 deletion(-)
- create mode 100644 coregrind/m_libgcc_sup.c
-
-diff --git a/Makefile.tool.am b/Makefile.tool.am
-index cc2fa0ee6..2bf90de5d 100644
---- a/Makefile.tool.am
-+++ b/Makefile.tool.am
-@@ -17,7 +17,8 @@ TOOL_DEPENDENCIES_@VGCONF_PLATFORM_SEC_CAPS@ = \
- endif
- 
- 
--TOOL_LDADD_COMMON = -lgcc
-+TOOL_LDADD_COMMON = -lgcc \
-+	$(top_builddir)/coregrind/libgcc-sup-@VGCONF_ARCH_PRI@-@VGCONF_OS@.a
- TOOL_LDADD_@VGCONF_PLATFORM_PRI_CAPS@ = \
- 	$(TOOL_DEPENDENCIES_@VGCONF_PLATFORM_PRI_CAPS@) $(TOOL_LDADD_COMMON)
- if VGCONF_HAVE_PLATFORM_SEC
-diff --git a/coregrind/Makefile.am b/coregrind/Makefile.am
-index 6a1a925fb..1753fb633 100644
---- a/coregrind/Makefile.am
-+++ b/coregrind/Makefile.am
-@@ -542,6 +542,32 @@ libcoregrind_@VGCONF_ARCH_SEC@_@VGCONF_OS@_a_DEPENDENCIES = \
-     libnolto_coregrind-@VGCONF_ARCH_SEC@-@VGCONF_OS@.a
- endif
- 
-+#----------------------------------------------------------------------------
-+# libgcc-sup-<platform>.a
-+# Special supplemental library for functions normally supplied by glibc
-+# used by libgcc.
-+#----------------------------------------------------------------------------
-+
-+pkglib_LIBRARIES  += libgcc-sup-@VGCONF_ARCH_PRI@-@VGCONF_OS@.a
-+if VGCONF_HAVE_PLATFORM_SEC
-+pkglib_LIBRARIES += libgcc-sup-@VGCONF_ARCH_SEC@-@VGCONF_OS@.a
-+endif
-+
-+libgcc_sup_@VGCONF_ARCH_PRI@_@VGCONF_OS@_a_SOURCES = \
-+	m_libgcc_sup.c
-+libgcc_sup_@VGCONF_ARCH_PRI@_@VGCONF_OS@_a_CPPFLAGS = \
-+	$(AM_CPPFLAGS_@VGCONF_PLATFORM_PRI_CAPS@)
-+libgcc_sup_@VGCONF_ARCH_PRI@_@VGCONF_OS@_a_CFLAGS = \
-+	$(AM_CFLAGS_PSO_@VGCONF_PLATFORM_PRI_CAPS@)
-+if VGCONF_HAVE_PLATFORM_SEC
-+libgcc_sup_@VGCONF_ARCH_SEC@_@VGCONF_OS@_a_SOURCES = \
-+	m_libgcc_sup.c
-+libgcc_sup_@VGCONF_ARCH_SEC@_@VGCONF_OS@_a_CPPFLAGS = \
-+	$(AM_CPPFLAGS_@VGCONF_PLATFORM_SEC_CAPS@)
-+libgcc_sup_@VGCONF_ARCH_SEC@_@VGCONF_OS@_a_CFLAGS = \
-+	$(AM_CFLAGS_PSO_@VGCONF_PLATFORM_SEC_CAPS@)
-+endif
-+
- #----------------------------------------------------------------------------
- # libreplacemalloc_toolpreload-<platform>.a
- #----------------------------------------------------------------------------
-diff --git a/coregrind/m_libgcc_sup.c b/coregrind/m_libgcc_sup.c
-new file mode 100644
-index 000000000..e29325459
---- /dev/null
-+++ b/coregrind/m_libgcc_sup.c
-@@ -0,0 +1,61 @@
-+/* -*- mode: C; c-basic-offset: 3; -*- */
-+
-+/*--------------------------------------------------------------------*/
-+/*--- Supplemental functions for libgcc normally provided by glibc ---*/
-+/*--------------------------------------------------------------------*/
-+
-+/*
-+   This file is part of Valgrind, a dynamic binary instrumentation
-+   framework.
-+
-+   Copyright (C) 2020 Mark Wielaard
-+      mark@klomp.org
-+
-+   This program is free software; you can redistribute it and/or
-+   modify it under the terms of the GNU General Public License as
-+   published by the Free Software Foundation; either version 2 of the
-+   License, or (at your option) any later version.
-+
-+   This program is distributed in the hope that it will be useful, but
-+   WITHOUT ANY WARRANTY; without even the implied warranty of
-+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+   General Public License for more details.
-+
-+   You should have received a copy of the GNU General Public License
-+   along with this program; if not, see <http://www.gnu.org/licenses/>.
-+
-+   The GNU General Public License is contained in the file COPYING.
-+*/
-+
-+#include "config.h"
-+#include "pub_core_basics.h"
-+#include "pub_core_clientstate.h"
-+
-+/*====================================================================*/
-+/*=== arm64 libgcc support function for init_have_lse_atomics      ===*/
-+/*====================================================================*/
-+
-+#if defined(VGP_arm64_linux)
-+struct auxv
-+{
-+   Word a_type;
-+   union {
-+      void *a_ptr;
-+      Word a_val;
-+   } u;
-+};
-+#define AT_NULL 0
-+
-+unsigned long int __getauxval (unsigned long int type);
-+unsigned long int __getauxval (unsigned long int type)
-+{
-+   struct auxv *p;
-+   for (p = (struct auxv *) VG_(client_auxv);
-+        p != NULL && p->a_type != AT_NULL;
-+        p++)
-+      if (p->a_type == type)
-+         return p->u.a_val;
-+
-+   return 0;
-+}
-+#endif
--- 
-2.26.2
-
diff --git a/poky/meta/recipes-devtools/valgrind/valgrind/0001-tests-Make-pthread_detatch-call-portable-across-plat.patch b/poky/meta/recipes-devtools/valgrind/valgrind/0001-tests-Make-pthread_detatch-call-portable-across-plat.patch
deleted file mode 100644
index f407d81..0000000
--- a/poky/meta/recipes-devtools/valgrind/valgrind/0001-tests-Make-pthread_detatch-call-portable-across-plat.patch
+++ /dev/null
@@ -1,87 +0,0 @@
-From 92fcf75d6d3903e45492b041bf4ad07787d2e58a Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Mon, 27 Jan 2020 19:50:04 -0800
-Subject: [PATCH] drd/tests/pth_detached3: Make pthread_detach() call portable
- across platforms
-
-pthread_t is opaque type therefore we can not apply simple arithmetic to
-variables of pthread_t type this test needs to pass a invalid pthread_t
-handle, typcasting to uintptr_t works too and is portable across glibc and
-musl
-
-Fixes
-| pth_detached3.c:24:25: error: invalid use of undefined type 'struct __pthread'
-|    24 |   pthread_detach(thread + 8);
-|       |                         ^
-
-[ bvanassche: reformatted patch description and fixed up line numbers ]
-
-Upstream-Status: Backport [https://sourceware.org/git/?p=valgrind.git;a=commit;h=92fcf75d6d3903e45492b041bf4ad07787d2e58a]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- drd/tests/pth_detached3.c           | 3 ++-
- drd/tests/pth_detached3.stderr.exp1 | 4 ++--
- drd/tests/pth_detached3.stderr.exp2 | 4 ++--
- 3 files changed, 6 insertions(+), 5 deletions(-)
-
-diff --git a/drd/tests/pth_detached3.c b/drd/tests/pth_detached3.c
-index c02eef1..efeb15b 100644
---- a/drd/tests/pth_detached3.c
-+++ b/drd/tests/pth_detached3.c
-@@ -4,6 +4,7 @@
- #include <errno.h>
- #include <pthread.h>
- #include <stdio.h>
-+#include <stdint.h>
- 
- static void* thread_func(void* arg)
- {
-@@ -21,7 +22,7 @@ int main(int argc, char** argv)
-   pthread_detach(thread);
- 
-   /* Invoke pthread_detach() with an invalid thread ID. */
--  pthread_detach(thread + 8);
-+  pthread_detach((pthread_t)((uintptr_t)thread + 8));
- 
-   fprintf(stderr, "Finished.\n");
- 
-diff --git a/drd/tests/pth_detached3.stderr.exp1 b/drd/tests/pth_detached3.stderr.exp1
-index 58412ec..8dd58ba 100644
---- a/drd/tests/pth_detached3.stderr.exp1
-+++ b/drd/tests/pth_detached3.stderr.exp1
-@@ -1,11 +1,11 @@
- 
- pthread_detach(): invalid thread ID 0x........
-    at 0x........: pthread_detach (drd_pthread_intercepts.c:?)
--   by 0x........: main (pth_detached3.c:21)
-+   by 0x........: main (pth_detached3.c:22)
- 
- pthread_detach(): invalid thread ID 0x........
-    at 0x........: pthread_detach (drd_pthread_intercepts.c:?)
--   by 0x........: main (pth_detached3.c:24)
-+   by 0x........: main (pth_detached3.c:25)
- 
- Finished.
- 
-diff --git a/drd/tests/pth_detached3.stderr.exp2 b/drd/tests/pth_detached3.stderr.exp2
-index bdc5cf8..e82dee1 100644
---- a/drd/tests/pth_detached3.stderr.exp2
-+++ b/drd/tests/pth_detached3.stderr.exp2
-@@ -2,12 +2,12 @@
- pthread_detach(): invalid thread ID 0x........
-    at 0x........: vgDrd_set_joinable (drd_pthread_intercepts.c:?)
-    by 0x........: pthread_detach (drd_pthread_intercepts.c:?)
--   by 0x........: main (pth_detached3.c:21)
-+   by 0x........: main (pth_detached3.c:22)
- 
- pthread_detach(): invalid thread ID 0x........
-    at 0x........: vgDrd_set_joinable (drd_pthread_intercepts.c:?)
-    by 0x........: pthread_detach (drd_pthread_intercepts.c:?)
--   by 0x........: main (pth_detached3.c:24)
-+   by 0x........: main (pth_detached3.c:25)
- 
- Finished.
- 
--- 
-2.9.3
-
diff --git a/poky/meta/recipes-devtools/valgrind/valgrind/0004-Fix-out-of-tree-builds.patch b/poky/meta/recipes-devtools/valgrind/valgrind/0004-Fix-out-of-tree-builds.patch
index 75bb0aa..4570f63 100644
--- a/poky/meta/recipes-devtools/valgrind/valgrind/0004-Fix-out-of-tree-builds.patch
+++ b/poky/meta/recipes-devtools/valgrind/valgrind/0004-Fix-out-of-tree-builds.patch
@@ -4,7 +4,8 @@
 Subject: [PATCH] Fix out of tree builds.
 
 The paths to these files need to be fully specified in
-the out of tree build case. glibc-2.X.supp is a generated file so the full path
+the out of tree build case. glibc-2.X.supp is a generated file so the
+full path
 is deliberately not specified in that case.
 
 RP 2013/03/23
@@ -16,81 +17,81 @@
 Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
 Signed-off-by: Randy MacLeod <Randy.MacLeod@windriver.com>
 ---
- configure.ac | 68 ++++++++++++++++++++++++++--------------------------
- 1 file changed, 34 insertions(+), 34 deletions(-)
+ configure.ac | 66 ++++++++++++++++++++++++++--------------------------
+ 1 file changed, 33 insertions(+), 33 deletions(-)
 
 diff --git a/configure.ac b/configure.ac
-index c18ae5f2a..99667ce57 100644
+index 524230d..54861c5 100755
 --- a/configure.ac
 +++ b/configure.ac
-@@ -392,50 +392,50 @@ case "${host_os}" in
+@@ -396,50 +396,50 @@ case "${host_os}" in
  	     9.*)
  		  AC_MSG_RESULT([Darwin 9.x (${kernel}) / Mac OS X 10.5 Leopard])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_5, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin9.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin9-drd.supp ${DEFAULT_SUPP}"
-+ 		  DEFAULT_SUPP="$srcdir/darwin9.supp ${DEFAULT_SUPP}"
-+ 		  DEFAULT_SUPP="$srcdir/darwin9-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin9.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin9-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     10.*)
  		  AC_MSG_RESULT([Darwin 10.x (${kernel}) / Mac OS X 10.6 Snow Leopard])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_6, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin10.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     11.*)
  		  AC_MSG_RESULT([Darwin 11.x (${kernel}) / Mac OS X 10.7 Lion])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_7, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin11.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin11.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin11.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     12.*)
  		  AC_MSG_RESULT([Darwin 12.x (${kernel}) / Mac OS X 10.8 Mountain Lion])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_8, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin12.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin12.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin12.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     13.*)
  		  AC_MSG_RESULT([Darwin 13.x (${kernel}) / Mac OS X 10.9 Mavericks])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_9, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin13.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin13.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin13.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     14.*)
  		  AC_MSG_RESULT([Darwin 14.x (${kernel}) / Mac OS X 10.10 Yosemite])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_10, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin14.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin14.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin14.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     15.*)
  		  AC_MSG_RESULT([Darwin 15.x (${kernel}) / Mac OS X 10.11 El Capitan])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_11, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin15.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin15.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin15.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     16.*)
  		  AC_MSG_RESULT([Darwin 16.x (${kernel}) / macOS 10.12 Sierra])
  		  AC_DEFINE([DARWIN_VERS], DARWIN_10_12, [Darwin / Mac OS X version])
 -		  DEFAULT_SUPP="darwin16.supp ${DEFAULT_SUPP}"
 -		  DEFAULT_SUPP="darwin10-drd.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin16.supp ${DEFAULT_SUPP}"
-+		  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin16.supp ${DEFAULT_SUPP}"
++                  DEFAULT_SUPP="$srcdir/darwin10-drd.supp ${DEFAULT_SUPP}"
  		  ;;
  	     17.*)
  		  AC_MSG_RESULT([Darwin 17.x (${kernel}) / macOS 10.13 High Sierra])
-@@ -460,7 +460,7 @@ case "${host_os}" in
+@@ -464,7 +464,7 @@ case "${host_os}" in
                   DEFAULT_SUPP="solaris12.supp ${DEFAULT_SUPP}"
                   ;;
               *)
@@ -99,7 +100,7 @@
                   ;;
  	esac
          ;;
-@@ -468,7 +468,7 @@ case "${host_os}" in
+@@ -472,7 +472,7 @@ case "${host_os}" in
       solaris2.12*)
          AC_MSG_RESULT([ok (${host_os})])
          VGCONF_OS="solaris"
@@ -108,33 +109,33 @@
          ;;
  
       *) 
-@@ -1051,29 +1051,29 @@ AC_MSG_CHECKING([the glibc version])
+@@ -1095,29 +1095,29 @@ AC_MSG_CHECKING([the glibc version])
  case "${GLIBC_VERSION}" in
       2.2)
  	AC_MSG_RESULT(${GLIBC_VERSION} family)
 -	DEFAULT_SUPP="glibc-2.2.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.2-LinuxThreads-helgrind.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.2.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.2-LinuxThreads-helgrind.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.2.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.2-LinuxThreads-helgrind.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
  	;;
       2.[[3-6]])
  	AC_MSG_RESULT(${GLIBC_VERSION} family)
 -	DEFAULT_SUPP="glibc-${GLIBC_VERSION}.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-${GLIBC_VERSION}.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-${GLIBC_VERSION}.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
  	;;
       2.[[7-9]])
  	AC_MSG_RESULT(${GLIBC_VERSION} family)
  	DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
  	;;
       2.10|2.11)
  	AC_MSG_RESULT(${GLIBC_VERSION} family)
@@ -143,23 +144,23 @@
  	DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
  	;;
       2.*)
  	AC_MSG_RESULT(${GLIBC_VERSION} family)
-@@ -1082,8 +1082,8 @@ case "${GLIBC_VERSION}" in
+@@ -1126,8 +1126,8 @@ case "${GLIBC_VERSION}" in
  	AC_DEFINE([GLIBC_MANDATORY_INDEX_AND_STRLEN_REDIRECT], 1,
  		  [Define to 1 if index() and strlen() have been optimized heavily (x86 glibc >= 2.12)])
  	DEFAULT_SUPP="glibc-2.X.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
 -	DEFAULT_SUPP="glibc-2.X-drd.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
-+	DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.34567-NPTL-helgrind.supp ${DEFAULT_SUPP}"
++        DEFAULT_SUPP="$srcdir/glibc-2.X-drd.supp ${DEFAULT_SUPP}"
  	;;
       darwin)
  	AC_MSG_RESULT(Darwin)
-@@ -1093,7 +1093,7 @@ case "${GLIBC_VERSION}" in
+@@ -1137,7 +1137,7 @@ case "${GLIBC_VERSION}" in
       bionic)
  	AC_MSG_RESULT(Bionic)
  	AC_DEFINE([BIONIC_LIBC], 1, [Define to 1 if you're using Bionic])
@@ -168,7 +169,7 @@
  	;;
       solaris)
  	AC_MSG_RESULT(Solaris)
-@@ -1120,11 +1120,11 @@ if test "$VGCONF_OS" != "solaris"; then
+@@ -1164,8 +1164,8 @@ if test "$VGCONF_OS" != "solaris"; then
      # attempt to detect whether such libraries are installed on the
      # build machine (or even if any X facilities are present); just
      # add the suppressions antidisirregardless.
@@ -176,13 +177,9 @@
 -    DEFAULT_SUPP="xfree-3.supp ${DEFAULT_SUPP}"
 +    DEFAULT_SUPP="$srcdir/xfree-4.supp ${DEFAULT_SUPP}"
 +    DEFAULT_SUPP="$srcdir/xfree-3.supp ${DEFAULT_SUPP}"
- 
-     # Add glibc and X11 suppressions for exp-sgcheck
--    DEFAULT_SUPP="exp-sgcheck.supp ${DEFAULT_SUPP}"
-+    DEFAULT_SUPP="$srcdir/exp-sgcheck.supp ${DEFAULT_SUPP}"
  fi
  
  
 -- 
-2.17.0
+2.17.1
 
diff --git a/poky/meta/recipes-devtools/valgrind/valgrind/0004-pth_atfork1.c-Define-error-API-for-musl.patch b/poky/meta/recipes-devtools/valgrind/valgrind/0004-pth_atfork1.c-Define-error-API-for-musl.patch
deleted file mode 100644
index 1cb7062..0000000
--- a/poky/meta/recipes-devtools/valgrind/valgrind/0004-pth_atfork1.c-Define-error-API-for-musl.patch
+++ /dev/null
@@ -1,37 +0,0 @@
-From fb77fef4f866dac7bcc6d1ae025da60564869f84 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Sat, 10 Jun 2017 01:06:11 -0700
-Subject: [PATCH 4/6] pth_atfork1.c: Define error() API for musl
-
-Upstream-Status: Pending
-
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- none/tests/pth_atfork1.c | 4 ++--
- 1 file changed, 2 insertions(+), 2 deletions(-)
-
-diff --git a/none/tests/pth_atfork1.c b/none/tests/pth_atfork1.c
-index 34201ef..b7f5f2d 100644
---- a/none/tests/pth_atfork1.c
-+++ b/none/tests/pth_atfork1.c
-@@ -18,7 +18,7 @@
-    Boston, MA 02111-1307, USA.  */
- 
- #include <errno.h>
--#if !defined(__APPLE__) && !defined(__sun)
-+#if !defined(__APPLE__) && !defined(__sun) && defined(__GLIBC__)
- # include <error.h>
- #endif
- #include <stdlib.h>
-@@ -27,7 +27,7 @@
- #include <sys/wait.h>
- #include <stdio.h>
- 
--#if defined(__APPLE__) || defined(__sun)
-+#if defined(__APPLE__) || defined(__sun) || (defined(__linux__) && !defined(__GLIBC__))
- #include <string.h>  /* strerror */
- static void error (int status, int errnum, char* msg)
- {
--- 
-2.13.1
-
diff --git a/poky/meta/recipes-devtools/valgrind/valgrind_3.15.0.bb b/poky/meta/recipes-devtools/valgrind/valgrind_3.16.0.bb
similarity index 95%
rename from poky/meta/recipes-devtools/valgrind/valgrind_3.15.0.bb
rename to poky/meta/recipes-devtools/valgrind/valgrind_3.16.0.bb
index a764d18..5402f39 100644
--- a/poky/meta/recipes-devtools/valgrind/valgrind_3.15.0.bb
+++ b/poky/meta/recipes-devtools/valgrind/valgrind_3.16.0.bb
@@ -3,7 +3,7 @@
 BUGTRACKER = "http://valgrind.org/support/bug_reports.html"
 LICENSE = "GPLv2 & GPLv2+ & BSD"
 LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263 \
-                    file://include/pub_tool_basics.h;beginline=6;endline=29;md5=d4de0407239381463cf01dd276d7c22e \
+                    file://include/pub_tool_basics.h;beginline=6;endline=29;md5=41c410e8d3f305aee7aaa666b2e4f366 \
                     file://include/valgrind.h;beginline=1;endline=56;md5=ad3b317f3286b6b704575d9efe6ca5df \
                     file://COPYING.DOCS;md5=24ea4c7092233849b4394699333b5c56"
 
@@ -27,7 +27,6 @@
            file://0001-sigqueue-Rename-_sifields-to-__si_fields-on-musl.patch \
            file://0002-context-APIs-are-not-available-on-musl.patch \
            file://0003-correct-include-directive-path-for-config.h.patch \
-           file://0004-pth_atfork1.c-Define-error-API-for-musl.patch \
            file://0005-tc20_verifywrap.c-Fake-__GLIBC_PREREQ-with-musl.patch \
            file://0001-memcheck-arm64-Define-__THROW-if-not-already-defined.patch \
            file://0002-memcheck-x86-Define-__THROW-if-not-defined.patch \
@@ -40,12 +39,10 @@
            file://0001-adjust-path-filter-for-2-memcheck-tests.patch \
            file://s390x_vec_op_t.patch \
            file://0001-none-tests-fdleak_cmsg.stderr.exp-adjust-tmp-paths.patch \
-           file://0001-tests-Make-pthread_detatch-call-portable-across-plat.patch \
            file://0001-memcheck-tests-Fix-timerfd-syscall-test.patch \
-           file://0001-gcc10-arm64-build-needs-__getauxval-for-linking-with.patch \
            "
-SRC_URI[md5sum] = "46e5fbdcbc3502a5976a317a0860a975"
-SRC_URI[sha256sum] = "417c7a9da8f60dd05698b3a7bc6002e4ef996f14c13f0ff96679a16873e78ab1"
+SRC_URI[md5sum] = "495b30af5e5ed62ebb9bb777ee19b27f"
+SRC_URI[sha256sum] = "582d5127ba56dfeaab4c6ced92a742b2921148e28a5d55055aedd8f75f1cf633"
 UPSTREAM_CHECK_REGEX = "valgrind-(?P<pver>\d+(\.\d+)+)\.tar"
 
 COMPATIBLE_HOST = '(i.86|x86_64|arm|aarch64|mips|powerpc|powerpc64).*-linux'
diff --git a/poky/meta/recipes-extended/asciidoc/asciidoc_8.6.9.bb b/poky/meta/recipes-extended/asciidoc/asciidoc_8.6.10.bb
similarity index 100%
rename from poky/meta/recipes-extended/asciidoc/asciidoc_8.6.9.bb
rename to poky/meta/recipes-extended/asciidoc/asciidoc_8.6.10.bb
diff --git a/poky/meta/recipes-extended/cups/cups_2.3.1.bb b/poky/meta/recipes-extended/cups/cups_2.3.1.bb
deleted file mode 100644
index f5230fa..0000000
--- a/poky/meta/recipes-extended/cups/cups_2.3.1.bb
+++ /dev/null
@@ -1,6 +0,0 @@
-require cups.inc
-
-LIC_FILES_CHKSUM = "file://LICENSE;md5=3b83ef96387f14655fc854ddc3c6bd57"
-
-SRC_URI[md5sum] = "8ad8897c97cf4d90f20dac4318f47421"
-SRC_URI[sha256sum] = "1bca9d89507e3f68cbc84482fe46ae8d5333af5bc2b9061347b2007182ac77ce"
diff --git a/poky/meta/recipes-extended/cups/cups_2.3.3.bb b/poky/meta/recipes-extended/cups/cups_2.3.3.bb
new file mode 100644
index 0000000..5caeb6f
--- /dev/null
+++ b/poky/meta/recipes-extended/cups/cups_2.3.3.bb
@@ -0,0 +1,6 @@
+require cups.inc
+
+LIC_FILES_CHKSUM = "file://LICENSE;md5=3b83ef96387f14655fc854ddc3c6bd57"
+
+SRC_URI[md5sum] = "412434ceefbdf3ec71bc9188a035f589"
+SRC_URI[sha256sum] = "261fd948bce8647b6d5cb2a1784f0c24cc52b5c4e827b71d726020bcc502f3ee"
diff --git a/poky/meta/recipes-extended/ethtool/ethtool/avoid_parallel_tests.patch b/poky/meta/recipes-extended/ethtool/ethtool/avoid_parallel_tests.patch
index d5c9324..2f2d04c 100644
--- a/poky/meta/recipes-extended/ethtool/ethtool/avoid_parallel_tests.patch
+++ b/poky/meta/recipes-extended/ethtool/ethtool/avoid_parallel_tests.patch
@@ -1,4 +1,4 @@
-From f8333f7759717b4d163cfe8e3ef8861c5a667324 Mon Sep 17 00:00:00 2001
+From 1c6c017e56ec536f5cceacdb02092777d390debb Mon Sep 17 00:00:00 2001
 From: Tudor Florea <tudor.florea@enea.com>
 Date: Wed, 28 May 2014 18:59:54 +0200
 Subject: [PATCH] ethtool: use serial-tests config needed by ptest.
@@ -15,15 +15,15 @@
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/configure.ac b/configure.ac
-index 2127fdb..4910e6f 100644
+index 1169b7f..ed82524 100644
 --- a/configure.ac
 +++ b/configure.ac
 @@ -2,7 +2,7 @@ dnl Process this file with autoconf to produce a configure script.
- AC_INIT(ethtool, 5.4, netdev@vger.kernel.org)
+ AC_INIT(ethtool, 5.6, netdev@vger.kernel.org)
  AC_PREREQ(2.52)
  AC_CONFIG_SRCDIR([ethtool.c])
--AM_INIT_AUTOMAKE([gnu])
-+AM_INIT_AUTOMAKE([gnu serial-tests])
+-AM_INIT_AUTOMAKE([gnu subdir-objects])
++AM_INIT_AUTOMAKE([gnu subdir-objects serial-tests])
  AC_CONFIG_HEADERS([ethtool-config.h])
  
  AM_MAINTAINER_MODE
diff --git a/poky/meta/recipes-extended/ethtool/ethtool/fix-printf.patch b/poky/meta/recipes-extended/ethtool/ethtool/fix-printf.patch
new file mode 100644
index 0000000..9effa4f
--- /dev/null
+++ b/poky/meta/recipes-extended/ethtool/ethtool/fix-printf.patch
@@ -0,0 +1,32 @@
+From 8dcdb3d22a66f18770e5566c0e72e86a0701aeac Mon Sep 17 00:00:00 2001
+From: Robert Scheck <robert@fedoraproject.org>
+Date: Tue, 12 May 2020 20:33:12 +0200
+Subject: Rewrite printf() due to -Werror=format-security
+
+Avoid -Werror=format-security leading to: netlink/settings.c:378:2: error:
+format not a string literal and no format arguments [-Werror=format-security]
+
+Upstream-Status: Backport
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+Signed-off-by: Robert Scheck <robert@fedoraproject.org>
+Signed-off-by: John W. Linville <linville@tuxdriver.com>
+---
+ netlink/settings.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/netlink/settings.c b/netlink/settings.c
+index c8a911d..0212465 100644
+--- a/netlink/settings.c
++++ b/netlink/settings.c
+@@ -375,7 +375,7 @@ static int dump_link_modes(struct nl_context *nlctx,
+ after:
+ 	if (first && if_none)
+ 		printf("%s", if_none);
+-	printf(after);
++	printf("%s", after);
+ 
+ 	return 0;
+ err:
+-- 
+cgit 1.2.3-1.el7
+
diff --git a/poky/meta/recipes-extended/ethtool/ethtool_5.4.bb b/poky/meta/recipes-extended/ethtool/ethtool_5.6.bb
similarity index 79%
rename from poky/meta/recipes-extended/ethtool/ethtool_5.4.bb
rename to poky/meta/recipes-extended/ethtool/ethtool_5.6.bb
index d6eafaa..eda32c8 100644
--- a/poky/meta/recipes-extended/ethtool/ethtool_5.4.bb
+++ b/poky/meta/recipes-extended/ethtool/ethtool_5.6.bb
@@ -9,17 +9,20 @@
 SRC_URI = "${KERNELORG_MIRROR}/software/network/ethtool/ethtool-${PV}.tar.gz \
            file://run-ptest \
            file://avoid_parallel_tests.patch \
+           file://fix-printf.patch \
            "
 
-SRC_URI[md5sum] = "fbb24aa414ab9a11ff66d351b5b8493b"
-SRC_URI[sha256sum] = "0b25a46b61bc6e26f56dcb973fc28acea159e2c32c9d6da42c0fa8d1a6339829"
+SRC_URI[sha256sum] = "e904e980294baf5878df410ebcf1d660497ba19bc3a77f798a04dba569f44a7e"
 
 UPSTREAM_CHECK_URI = "https://www.kernel.org/pub/software/network/ethtool/"
 
-inherit autotools ptest bash-completion
+inherit autotools ptest bash-completion pkgconfig
 
 RDEPENDS_${PN}-ptest += "make"
 
+PACKAGECONFIG ?= "netlink"
+PACKAGECONFIG[netlink] = "--enable-netlink,--disable-netlink,libmnl,"
+
 do_compile_ptest() {
    oe_runmake buildtest-TESTS
 }
diff --git a/poky/meta/recipes-extended/gawk/gawk_5.0.1.bb b/poky/meta/recipes-extended/gawk/gawk_5.1.0.bb
similarity index 91%
rename from poky/meta/recipes-extended/gawk/gawk_5.0.1.bb
rename to poky/meta/recipes-extended/gawk/gawk_5.1.0.bb
index e79ccfd..0d005cd 100644
--- a/poky/meta/recipes-extended/gawk/gawk_5.0.1.bb
+++ b/poky/meta/recipes-extended/gawk/gawk_5.1.0.bb
@@ -19,8 +19,8 @@
            file://run-ptest \
 "
 
-SRC_URI[md5sum] = "c5441c73cc451764055ee65e9a4292bb"
-SRC_URI[sha256sum] = "625bf3718e25a84dc4486135d5cb5388174682362c70107fd13f21572f5603bb"
+SRC_URI[md5sum] = "f719bc9966df28e67fc6ebc405e7ea03"
+SRC_URI[sha256sum] = "03a0360edcd84bec156fe211bbc4fc8c78790973ce4e8b990a11d778d40b1a26"
 
 inherit autotools gettext texinfo update-alternatives
 
diff --git a/poky/meta/recipes-extended/less/less_551.bb b/poky/meta/recipes-extended/less/less_562.bb
similarity index 89%
rename from poky/meta/recipes-extended/less/less_551.bb
rename to poky/meta/recipes-extended/less/less_562.bb
index a818c68..c900574 100644
--- a/poky/meta/recipes-extended/less/less_551.bb
+++ b/poky/meta/recipes-extended/less/less_562.bb
@@ -28,8 +28,8 @@
 SRC_URI = "http://www.greenwoodsoftware.com/${BPN}/${BPN}-${PV}.tar.gz \
 	  "
 
-SRC_URI[md5sum] = "4ad4408b06d7a6626a055cb453f36819"
-SRC_URI[sha256sum] = "ff165275859381a63f19135a8f1f6c5a194d53ec3187f94121ecd8ef0795fe3d"
+SRC_URI[md5sum] = "0371a9678cb42f37b9bf9b86e8aa7903"
+SRC_URI[sha256sum] = "eab470c7c928132441541aa49b1352c0fc699c30f762dfaeb3bf88e6f0fd701b"
 
 UPSTREAM_CHECK_URI = "http://www.greenwoodsoftware.com/less/download.html"
 
diff --git a/poky/meta/recipes-extended/libsolv/libsolv_0.7.10.bb b/poky/meta/recipes-extended/libsolv/libsolv_0.7.14.bb
similarity index 84%
rename from poky/meta/recipes-extended/libsolv/libsolv_0.7.10.bb
rename to poky/meta/recipes-extended/libsolv/libsolv_0.7.14.bb
index 265a27c..5179d45 100644
--- a/poky/meta/recipes-extended/libsolv/libsolv_0.7.10.bb
+++ b/poky/meta/recipes-extended/libsolv/libsolv_0.7.14.bb
@@ -10,7 +10,7 @@
 SRC_URI = "git://github.com/openSUSE/libsolv.git \
 "
 
-SRCREV = "605dd2645ef899e2b7c95709476fb51e28d7e378"
+SRCREV = "b264537ea43ce39d93d8d97fcca16e97825beaa0"
 
 UPSTREAM_CHECK_GITTAGREGEX = "(?P<pver>\d+(\.\d+)+)"
 
@@ -19,7 +19,7 @@
 inherit cmake
 
 PACKAGECONFIG ??= "${@bb.utils.contains('PACKAGE_CLASSES','package_rpm','rpm','',d)}"
-PACKAGECONFIG[rpm] = "-DENABLE_RPMMD=ON -DENABLE_RPMDB=ON,,rpm"
+PACKAGECONFIG[rpm] = "-DENABLE_RPMMD=ON -DENABLE_RPMDB=ON -DENABLE_RPMDB_BDB=ON,,rpm"
 
 EXTRA_OECMAKE = "-DMULTI_SEMANTICS=ON -DENABLE_COMPLEX_DEPS=ON"
 
diff --git a/poky/meta/recipes-extended/logrotate/logrotate_3.16.0.bb b/poky/meta/recipes-extended/logrotate/logrotate_3.16.0.bb
index 2b6ee0a..1c9df5a 100644
--- a/poky/meta/recipes-extended/logrotate/logrotate_3.16.0.bb
+++ b/poky/meta/recipes-extended/logrotate/logrotate_3.16.0.bb
@@ -9,13 +9,6 @@
 
 LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"
 
-# When updating logrotate to latest upstream, SRC_URI should point to
-# a proper release tarball from https://github.com/logrotate/logrotate/releases
-# and we have to take the snapshot for now because there is no such
-# tarball available for 3.9.1.
-
-S = "${WORKDIR}/${BPN}-${PV}"
-
 UPSTREAM_CHECK_URI = "https://github.com/${BPN}/${BPN}/releases"
 UPSTREAM_CHECK_REGEX = "logrotate-(?P<pver>\d+(\.\d+)+).tar"
 
diff --git a/poky/meta/recipes-extended/ltp/ltp/0001-sigwaitinfo-Do-not-run-invalid-undefined-test-cases.patch b/poky/meta/recipes-extended/ltp/ltp/0001-sigwaitinfo-Do-not-run-invalid-undefined-test-cases.patch
new file mode 100644
index 0000000..17d5af8
--- /dev/null
+++ b/poky/meta/recipes-extended/ltp/ltp/0001-sigwaitinfo-Do-not-run-invalid-undefined-test-cases.patch
@@ -0,0 +1,69 @@
+From e0a63deb1857eb90288e90d6368df70cdd0c0ec9 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 28 May 2020 13:04:33 -0700
+Subject: [PATCH] sigwaitinfo: Do not run invalid/undefined test cases
+
+These testcases run for eternity on musl
+
+test_bad_address* cases are passing invalid pointers to a function; that's always UB
+empty_set and timeout rely on the implementation-defined "may fail" for EINTR in sigtimedwait [1]
+
+normally "may fail" is an "unspecified" but here the impl
+is supposed to document it so it's "impl-defined"
+
+[1] https://pubs.opengroup.org/onlinepubs/9699919799/functions/sigtimedwait.html
+
+Upstream-Status: Submitted [https://patchwork.ozlabs.org/project/ltp/patch/20200528204556.2444156-1-raj.khem@gmail.com/]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+Cc: Rich Felker <dalias@aerifal.cx>
+---
+ .../kernel/syscalls/sigwaitinfo/sigwaitinfo01.c      | 12 ++----------
+ 1 file changed, 2 insertions(+), 10 deletions(-)
+
+--- a/testcases/kernel/syscalls/sigwaitinfo/sigwaitinfo01.c
++++ b/testcases/kernel/syscalls/sigwaitinfo/sigwaitinfo01.c
+@@ -422,15 +422,10 @@ struct test_desc {
+ } tests[] = {
+ #ifdef TEST_RT_SIGTIMEDWAIT
+ 	{
+-	test_empty_set, my_rt_sigtimedwait, SIGUSR1}, {
+ 	test_unmasked_matching, my_rt_sigtimedwait, SIGUSR1}, {
+ 	test_masked_matching, my_rt_sigtimedwait, SIGUSR1}, {
+ 	test_unmasked_matching_noinfo, my_rt_sigtimedwait, SIGUSR1}, {
+-	test_masked_matching_noinfo, my_rt_sigtimedwait, SIGUSR1}, {
+-	test_bad_address, my_rt_sigtimedwait, SIGUSR1}, {
+-	test_bad_address2, my_rt_sigtimedwait, SIGUSR1}, {
+-	test_bad_address3, my_rt_sigtimedwait, SIGUSR1}, {
+-	test_timeout, my_rt_sigtimedwait, 0},
++	test_masked_matching_noinfo, my_rt_sigtimedwait, SIGUSR1}, 
+ 	    /* Special cases */
+ 	    /* 1: sigwaitinfo does respond to ignored signal */
+ 	{
+@@ -452,25 +447,17 @@ struct test_desc {
+ #endif
+ #if defined TEST_SIGWAITINFO
+ 	{
+-	test_empty_set, my_sigwaitinfo, SIGUSR1}, {
+ 	test_unmasked_matching, my_sigwaitinfo, SIGUSR1}, {
+ 	test_masked_matching, my_sigwaitinfo, SIGUSR1}, {
+ 	test_unmasked_matching_noinfo, my_sigwaitinfo, SIGUSR1}, {
+-	test_masked_matching_noinfo, my_sigwaitinfo, SIGUSR1}, {
+-	test_bad_address, my_sigwaitinfo, SIGUSR1}, {
+-	test_bad_address2, my_sigwaitinfo, SIGUSR1},
++	test_masked_matching_noinfo, my_sigwaitinfo, SIGUSR1},
+ #endif
+ #if defined TEST_SIGTIMEDWAIT
+ 	{
+-	test_empty_set, my_sigtimedwait, SIGUSR1}, {
+ 	test_unmasked_matching, my_sigtimedwait, SIGUSR1}, {
+ 	test_masked_matching, my_sigtimedwait, SIGUSR1}, {
+ 	test_unmasked_matching_noinfo, my_sigtimedwait, SIGUSR1}, {
+-	test_masked_matching_noinfo, my_sigtimedwait, SIGUSR1}, {
+-	test_bad_address, my_sigtimedwait, SIGUSR1}, {
+-	test_bad_address2, my_sigtimedwait, SIGUSR1}, {
+-	test_bad_address3, my_sigtimedwait, SIGUSR1}, {
+-	test_timeout, my_sigtimedwait, 0},
++	test_masked_matching_noinfo, my_sigtimedwait, SIGUSR1},
+ #endif
+ };
+ 
diff --git a/poky/meta/recipes-extended/ltp/ltp_20200515.bb b/poky/meta/recipes-extended/ltp/ltp_20200515.bb
index 67c7590..f2510ba 100644
--- a/poky/meta/recipes-extended/ltp/ltp_20200515.bb
+++ b/poky/meta/recipes-extended/ltp/ltp_20200515.bb
@@ -35,6 +35,7 @@
            file://0007-Fix-test_proc_kill-hanging.patch \
            file://0001-Add-more-musl-exclusions.patch \
            file://0001-ptrace01-Fix-missing-format-string.patch \
+           file://0001-sigwaitinfo-Do-not-run-invalid-undefined-test-cases.patch \
            "
 
 S = "${WORKDIR}/git"
diff --git a/poky/meta/recipes-extended/man-pages/man-pages_5.05.bb b/poky/meta/recipes-extended/man-pages/man-pages_5.06.bb
similarity index 87%
rename from poky/meta/recipes-extended/man-pages/man-pages_5.05.bb
rename to poky/meta/recipes-extended/man-pages/man-pages_5.06.bb
index b95872e..0d632e6 100644
--- a/poky/meta/recipes-extended/man-pages/man-pages_5.05.bb
+++ b/poky/meta/recipes-extended/man-pages/man-pages_5.06.bb
@@ -7,8 +7,8 @@
 LIC_FILES_CHKSUM = "file://README;md5=794f701617cc03fe50c53257660d8ec4"
 SRC_URI = "${KERNELORG_MIRROR}/linux/docs/${BPN}/${BP}.tar.gz"
 
-SRC_URI[md5sum] = "cdad5deb15117e60a6d9e3a6bdc035b5"
-SRC_URI[sha256sum] = "43c33d2eea9ba989c18eef90298cf6d5521ff038deb51cda0ecd0fdc3cec2b7d"
+SRC_URI[md5sum] = "ebddb52ea013c160f07fd0a4a7e9266d"
+SRC_URI[sha256sum] = "da4e939c624bec4bab8ca1702e5f54bbc70505090d90967fd5e12bc1453f19b0"
 
 inherit manpages
 
diff --git a/poky/meta/recipes-extended/msmtp/msmtp_1.8.8.bb b/poky/meta/recipes-extended/msmtp/msmtp_1.8.10.bb
similarity index 86%
rename from poky/meta/recipes-extended/msmtp/msmtp_1.8.8.bb
rename to poky/meta/recipes-extended/msmtp/msmtp_1.8.10.bb
index ca359a1..42cf630 100644
--- a/poky/meta/recipes-extended/msmtp/msmtp_1.8.8.bb
+++ b/poky/meta/recipes-extended/msmtp/msmtp_1.8.10.bb
@@ -11,8 +11,8 @@
 UPSTREAM_CHECK_URI = "https://marlam.de/msmtp/download/"
 
 SRC_URI = "https://marlam.de/${BPN}/releases/${BP}.tar.xz"
-SRC_URI[md5sum] = "016e432d12e12dc5d73960e2bc67f0fb"
-SRC_URI[sha256sum] = "eccb53e48f025f7e6f60210316df61cf6097a491728341c1e375fc1acc6459e5"
+SRC_URI[md5sum] = "168430e48f351b5a157ad930d7db3ecc"
+SRC_URI[sha256sum] = "caba7f39d19df7a31782fe7336dd640c61ea33b92f987bd5423bca9683482f10"
 
 inherit gettext autotools update-alternatives pkgconfig
 
diff --git a/poky/meta/recipes-extended/stress-ng/stress-ng_0.11.01.bb b/poky/meta/recipes-extended/stress-ng/stress-ng_0.11.12.bb
similarity index 83%
rename from poky/meta/recipes-extended/stress-ng/stress-ng_0.11.01.bb
rename to poky/meta/recipes-extended/stress-ng/stress-ng_0.11.12.bb
index 3486be1..45f4bb4 100644
--- a/poky/meta/recipes-extended/stress-ng/stress-ng_0.11.01.bb
+++ b/poky/meta/recipes-extended/stress-ng/stress-ng_0.11.12.bb
@@ -8,8 +8,7 @@
 SRC_URI = "https://kernel.ubuntu.com/~cking/tarballs/${BPN}/${BP}.tar.xz \
            file://0001-Do-not-preserve-ownership-when-installing-example-jo.patch \
            "
-SRC_URI[md5sum] = "a558fc7fb9d0a851afe6de09080b5401"
-SRC_URI[sha256sum] = "9fe19548c87aa1a1b9b2be3b359ec2621b88bcb16998b77527549a7736f65494"
+SRC_URI[sha256sum] = "0ccf437ca1876a3e8a55986c6481697045203a17f5994cb2f5096cd461d18031"
 
 DEPENDS = "coreutils-native"
 
@@ -23,3 +22,5 @@
 do_install() {
     oe_runmake DESTDIR=${D} install
 }
+
+COMPATIBLE_HOST_libc-musl = 'null'
diff --git a/poky/meta/recipes-extended/sudo/sudo.inc b/poky/meta/recipes-extended/sudo/sudo.inc
index 5d27d46..86a18be 100644
--- a/poky/meta/recipes-extended/sudo/sudo.inc
+++ b/poky/meta/recipes-extended/sudo/sudo.inc
@@ -4,7 +4,7 @@
 BUGTRACKER = "http://www.sudo.ws/bugs/"
 SECTION = "admin"
 LICENSE = "ISC & BSD & Zlib"
-LIC_FILES_CHKSUM = "file://doc/LICENSE;md5=4d1b44b1576eea036d78b8cc961aa93d \
+LIC_FILES_CHKSUM = "file://doc/LICENSE;md5=828cd502ad216ff869bf83adf3301e02 \
                     file://plugins/sudoers/redblack.c;beginline=1;endline=46;md5=03e35317699ba00b496251e0dfe9f109 \
                     file://lib/util/reallocarray.c;beginline=3;endline=15;md5=397dd45c7683e90b9f8bf24638cf03bf \
                     file://lib/util/fnmatch.c;beginline=3;endline=27;md5=004d7d2866ba1f5b41174906849d2e0f \
diff --git a/poky/meta/recipes-extended/sudo/sudo_1.8.31.bb b/poky/meta/recipes-extended/sudo/sudo_1.9.0.bb
similarity index 92%
rename from poky/meta/recipes-extended/sudo/sudo_1.8.31.bb
rename to poky/meta/recipes-extended/sudo/sudo_1.9.0.bb
index 39d8817..7626653 100644
--- a/poky/meta/recipes-extended/sudo/sudo_1.8.31.bb
+++ b/poky/meta/recipes-extended/sudo/sudo_1.9.0.bb
@@ -7,8 +7,8 @@
 
 PAM_SRC_URI = "file://sudo.pam"
 
-SRC_URI[md5sum] = "ce17ff6e72a70f8d5dabba8abf3cd2de"
-SRC_URI[sha256sum] = "7ea8d97a3cee4c844e0887ea7a1bd80eb54cc98fd77966776cb1a80653ad454f"
+SRC_URI[md5sum] = "060b91a6b171cb7ce587222664549b2c"
+SRC_URI[sha256sum] = "ab231439c5dfdf4ecbef74f10d5f7e9686c2255c2f3887085b5c5e13281bf95c"
 
 DEPENDS += " virtual/crypt ${@bb.utils.contains('DISTRO_FEATURES', 'pam', 'libpam', '', d)}"
 RDEPENDS_${PN} += " ${@bb.utils.contains('DISTRO_FEATURES', 'pam', 'pam-plugin-limits pam-plugin-keyinit', '', d)}"
diff --git a/poky/meta/recipes-extended/xinetd/xinetd_2.3.15.bb b/poky/meta/recipes-extended/xinetd/xinetd_2.3.15.bb
index 6e43f5b..8f8f846 100644
--- a/poky/meta/recipes-extended/xinetd/xinetd_2.3.15.bb
+++ b/poky/meta/recipes-extended/xinetd/xinetd_2.3.15.bb
@@ -9,10 +9,9 @@
 DEPENDS += "libtirpc"
 PR = "r2"
 
-# Blacklist a bogus tag in upstream check
-UPSTREAM_CHECK_GITTAGREGEX = "xinetd-(?P<pver>(?!20030122).+)"
+UPSTREAM_CHECK_GITTAGREGEX = "(?P<pver>\d+(\.\d+)+)"
 
-SRC_URI = "git://github.com/xinetd-org/xinetd.git;protocol=https \
+SRC_URI = "git://github.com/openSUSE/xinetd.git;protocol=https \
       file://xinetd.init \
       file://xinetd.conf \
       file://xinetd.default \
@@ -23,7 +22,6 @@
       file://0001-configure-Use-HAVE_SYS_RESOURCE_H-to-guard-sys-resou.patch \
       file://xinetd.service \
       "
-UPSTREAM_VERSION_UNKNOWN = "1"
 
 SRCREV = "68bb9ab9e9f214ad8a2322f28ac1d6733e70bc24"
 
diff --git a/poky/meta/recipes-gnome/gnome/adwaita-icon-theme/0001-Don-t-use-AC_CANONICAL_HOST.patch b/poky/meta/recipes-gnome/gnome/adwaita-icon-theme/0001-Don-t-use-AC_CANONICAL_HOST.patch
index 372f144..5da3fbf 100644
--- a/poky/meta/recipes-gnome/gnome/adwaita-icon-theme/0001-Don-t-use-AC_CANONICAL_HOST.patch
+++ b/poky/meta/recipes-gnome/gnome/adwaita-icon-theme/0001-Don-t-use-AC_CANONICAL_HOST.patch
@@ -1,4 +1,4 @@
-From 4409423752885f76326d05c1266698155f47c5f9 Mon Sep 17 00:00:00 2001
+From 0a867caa8803a78f7cf3a204c4c358bc63daaf28 Mon Sep 17 00:00:00 2001
 From: Jussi Kukkonen <jussi.kukkonen@intel.com>
 Date: Tue, 30 May 2017 14:55:49 +0300
 Subject: [PATCH] Don't use AC_CANONICAL_HOST
@@ -14,12 +14,12 @@
  1 file changed, 1 deletion(-)
 
 diff --git a/configure.ac b/configure.ac
-index 4a84501..52dbb8e 100644
+index e749112..58790e8 100644
 --- a/configure.ac
 +++ b/configure.ac
 @@ -3,7 +3,6 @@ AC_PREREQ(2.53)
  
- AC_INIT([adwaita-icon-theme], [3.34.3],
+ AC_INIT([adwaita-icon-theme], [3.36.1],
          [http://bugzilla.gnome.org/enter_bug.cgi?product=adwaita-icon-theme])
 -AC_CANONICAL_HOST
  AC_CONFIG_MACRO_DIR([m4])
diff --git a/poky/meta/recipes-gnome/gnome/adwaita-icon-theme_3.34.3.bb b/poky/meta/recipes-gnome/gnome/adwaita-icon-theme_3.36.1.bb
similarity index 92%
rename from poky/meta/recipes-gnome/gnome/adwaita-icon-theme_3.34.3.bb
rename to poky/meta/recipes-gnome/gnome/adwaita-icon-theme_3.36.1.bb
index 3a2727b..473e1fc 100644
--- a/poky/meta/recipes-gnome/gnome/adwaita-icon-theme_3.34.3.bb
+++ b/poky/meta/recipes-gnome/gnome/adwaita-icon-theme_3.36.1.bb
@@ -14,8 +14,8 @@
            file://0001-Run-installation-commands-as-shell-jobs.patch \
            "
 
-SRC_URI[md5sum] = "9aea4ad9bc002aacad155ee0748b357f"
-SRC_URI[sha256sum] = "e7c2d8c259125d5f35ec09522b88c8fe7ecf625224ab0811213ef0a95d90b908"
+SRC_URI[md5sum] = "c61ca9d6b3ce70a9ab66dcff945923ff"
+SRC_URI[sha256sum] = "e498518627044dfd7db7d79a5b3d437848caf1991ef4ef036a2d3a2ac2c1f14d"
 
 DEPENDS += "librsvg-native"
 
diff --git a/poky/meta/recipes-gnome/gtk+/gtk+3.inc b/poky/meta/recipes-gnome/gtk+/gtk+3.inc
index 6154154..e1ecf50 100644
--- a/poky/meta/recipes-gnome/gtk+/gtk+3.inc
+++ b/poky/meta/recipes-gnome/gtk+/gtk+3.inc
@@ -106,6 +106,7 @@
 FILES_${PN}-dev += " \
                     ${datadir}/gtk-3.0/gtkbuilder.rng \
                     ${datadir}/gtk-3.0/include \
+                    ${datadir}/gtk-3.0/valgrind \
                     ${datadir}/gettext/its \
                     ${libdir}/gtk-3.0/include \
                     ${libdir}/gtk-3.0/${LIBV}/loaders/*.la \
diff --git a/poky/meta/recipes-gnome/gtk+/gtk+3/sort-resources.patch b/poky/meta/recipes-gnome/gtk+/gtk+3/sort-resources.patch
deleted file mode 100644
index 7f87372..0000000
--- a/poky/meta/recipes-gnome/gtk+/gtk+3/sort-resources.patch
+++ /dev/null
@@ -1,19 +0,0 @@
-If the resources file isn't sorted in some way then libgdk.so will differ
-depending on the inode order of the resource files.
-
-Upstream-Status: Pending
-Signed-off-by: Ross Burton <ross.burton@intel.com>
-
-diff --git a/gdk/Makefile.am b/gdk/Makefile.am
-index e25b57ba50..26f2d57c6e 100644
---- a/gdk/Makefile.am
-+++ b/gdk/Makefile.am
-@@ -465,7 +465,7 @@ stamp-gc-h: $(top_builddir)/config.status
- # Resources
- #
- 
--glsl_sources := $(wildcard $(srcdir)/resources/glsl/*.glsl)
-+glsl_sources := $(sort $(wildcard $(srcdir)/resources/glsl/*.glsl))
- 
- gdk.gresource.xml: Makefile.am
- 	$(AM_V_GEN) echo "<?xml version='1.0' encoding='UTF-8'?>" > $@; \
diff --git a/poky/meta/recipes-gnome/gtk+/gtk+3_3.24.14.bb b/poky/meta/recipes-gnome/gtk+/gtk+3_3.24.20.bb
similarity index 79%
rename from poky/meta/recipes-gnome/gtk+/gtk+3_3.24.14.bb
rename to poky/meta/recipes-gnome/gtk+/gtk+3_3.24.20.bb
index ab1f87c..e5744a4 100644
--- a/poky/meta/recipes-gnome/gtk+/gtk+3_3.24.14.bb
+++ b/poky/meta/recipes-gnome/gtk+/gtk+3_3.24.20.bb
@@ -7,10 +7,9 @@
            file://0002-Do-not-try-to-initialize-GL-without-libGL.patch \
            file://0003-Add-disable-opengl-configure-option.patch \
            file://link_fribidi.patch \
-           file://sort-resources.patch \
-          "
-SRC_URI[md5sum] = "62e39212fa0a84016a3392a9d291faf8"
-SRC_URI[sha256sum] = "1c4d69f93ab884fd80c6b95115bfbc12d51ecd029178b6dad3672fdc5ff91e88"
+           "
+SRC_URI[md5sum] = "b302acc0a4b42e2980ef18628f9ce951"
+SRC_URI[sha256sum] = "2dac69f716e8d04ba7a95091589e2baaec95dcace932cb15839163db479b1df3"
 
 S = "${WORKDIR}/gtk+-${PV}"
 
diff --git a/poky/meta/recipes-gnome/gtk-doc/gtk-doc_1.32.bb b/poky/meta/recipes-gnome/gtk-doc/gtk-doc_1.32.bb
index b508e62..1eaf370 100644
--- a/poky/meta/recipes-gnome/gtk-doc/gtk-doc_1.32.bb
+++ b/poky/meta/recipes-gnome/gtk-doc/gtk-doc_1.32.bb
@@ -40,7 +40,7 @@
     # configure values for python3 and pkg-config encoded in scripts
     for fn in ${bindir}/gtkdoc-depscan \
         ${bindir}/gtkdoc-mkhtml2 \
-        ${datadir}/gtk-doc/python/gtkdoc/config.py; do 
+        ${datadir}/gtk-doc/python/gtkdoc/config.py; do
         sed -e 's,${RECIPE_SYSROOT_NATIVE}/usr/bin/pkg-config,${bindir}/pkg-config,' \
             -e 's,${HOSTTOOLS_DIR}/python3,${bindir}/python3,' \
             -i ${D}$fn
diff --git a/poky/meta/recipes-gnome/librsvg/librsvg_2.40.20.bb b/poky/meta/recipes-gnome/librsvg/librsvg_2.40.20.bb
index 6dd0533..337299f 100644
--- a/poky/meta/recipes-gnome/librsvg/librsvg_2.40.20.bb
+++ b/poky/meta/recipes-gnome/librsvg/librsvg_2.40.20.bb
@@ -14,7 +14,7 @@
 
 SECTION = "x11/utils"
 DEPENDS = "cairo gdk-pixbuf glib-2.0 libcroco libxml2 pango"
-BBCLASSEXTEND = "native"
+BBCLASSEXTEND = "native nativesdk"
 
 inherit gnomebase gtk-doc pixbufcache upstream-version-is-even gobject-introspection
 
diff --git a/poky/meta/recipes-graphics/cairo/cairo_1.16.0.bb b/poky/meta/recipes-graphics/cairo/cairo_1.16.0.bb
index 092c77b..68f993d 100644
--- a/poky/meta/recipes-graphics/cairo/cairo_1.16.0.bb
+++ b/poky/meta/recipes-graphics/cairo/cairo_1.16.0.bb
@@ -23,7 +23,7 @@
 DEPENDS = "fontconfig glib-2.0 libpng pixman zlib"
 
 SRC_URI = "http://cairographics.org/releases/cairo-${PV}.tar.xz \
-           file://cairo-get_bitmap_surface-bsc1036789-CVE-2017-7475.diff \ 
+           file://cairo-get_bitmap_surface-bsc1036789-CVE-2017-7475.diff \
            file://CVE-2018-19876.patch \
            file://CVE-2019-6461.patch \
            file://CVE-2019-6462.patch \
@@ -70,8 +70,10 @@
 	rm -rf ${D}${libdir}/cairo/cairo-sphinx*
 	rm -rf ${D}${libdir}/cairo/.debug/cairo-fdr*
 	rm -rf ${D}${libdir}/cairo/.debug/cairo-sphinx*
-	rmdir -p --ignore-fail-on-non-empty ${D}${bindir}
-	rmdir -p --ignore-fail-on-non-empty ${D}${libdir}/cairo
+	[ ! -d ${D}${bindir} ] ||
+		rmdir -p --ignore-fail-on-non-empty ${D}${bindir}
+	[ ! -d ${D}${libdir}/cairo ] ||
+		rmdir -p --ignore-fail-on-non-empty ${D}${libdir}/cairo
 }
 
 PACKAGES =+ "cairo-gobject cairo-script-interpreter cairo-perf-utils"
diff --git a/poky/meta/recipes-graphics/cogl/cogl-1.0.inc b/poky/meta/recipes-graphics/cogl/cogl-1.0.inc
index d8d0665..1c5d0b7 100644
--- a/poky/meta/recipes-graphics/cogl/cogl-1.0.inc
+++ b/poky/meta/recipes-graphics/cogl/cogl-1.0.inc
@@ -3,7 +3,7 @@
 hardware for rendering. The API departs from the flat state machine style of \
 OpenGL and is designed to make it easy to write orthogonal components that \
 can render without stepping on each others toes."
-HOMEPAGE = "http://wiki.clutter-project.org/wiki/Cogl"
+HOMEPAGE = "https://gitlab.gnome.org/GNOME/cogl"
 LICENSE = "MIT"
 
 inherit clutter features_check upstream-version-is-even gobject-introspection
diff --git a/poky/meta/recipes-graphics/cogl/cogl-1.0_1.22.4.bb b/poky/meta/recipes-graphics/cogl/cogl-1.0_1.22.4.bb
deleted file mode 100644
index 8e61c19..0000000
--- a/poky/meta/recipes-graphics/cogl/cogl-1.0_1.22.4.bb
+++ /dev/null
@@ -1,6 +0,0 @@
-require cogl-1.0.inc
-
-SRC_URI[archive.md5sum] = "31755015a865c4af51ac84f6e53af8ab"
-SRC_URI[archive.sha256sum] = "5217bf94cbca3df63268a3b79d017725382b9e592b891d1e7dc6212590ce0de0"
-
-LIC_FILES_CHKSUM = "file://COPYING;md5=1b1a508d91d25ca607c83f92f3e31c84"
diff --git a/poky/meta/recipes-graphics/cogl/cogl-1.0_1.22.6.bb b/poky/meta/recipes-graphics/cogl/cogl-1.0_1.22.6.bb
new file mode 100644
index 0000000..86bbdbf
--- /dev/null
+++ b/poky/meta/recipes-graphics/cogl/cogl-1.0_1.22.6.bb
@@ -0,0 +1,6 @@
+require cogl-1.0.inc
+
+SRC_URI[archive.md5sum] = "7bcc01edb5462d4d08d01bf893feddb0"
+SRC_URI[archive.sha256sum] = "6d134bd3e48c067507167c001200b275997fb9c68b08b48ff038211c8c251b75"
+
+LIC_FILES_CHKSUM = "file://COPYING;md5=1b1a508d91d25ca607c83f92f3e31c84"
diff --git a/poky/meta/recipes-graphics/jpeg/libjpeg-turbo_2.0.4.bb b/poky/meta/recipes-graphics/jpeg/libjpeg-turbo_2.0.4.bb
index 1f49fd3..62ad504 100644
--- a/poky/meta/recipes-graphics/jpeg/libjpeg-turbo_2.0.4.bb
+++ b/poky/meta/recipes-graphics/jpeg/libjpeg-turbo_2.0.4.bb
@@ -8,7 +8,7 @@
                     file://djpeg.c;endline=11;md5=c59e19811c006cb38f82d6477134d314 \
 "
 DEPENDS_append_x86-64_class-target = " nasm-native"
-DEPENDS_append_x86_class-target    = " nasm-native"
+DEPENDS_append_x86_class-target = " nasm-native"
 
 SRC_URI = "${SOURCEFORGE_MIRROR}/${BPN}/${BPN}-${PV}.tar.gz \
            file://0001-libjpeg-turbo-fix-package_qa-error.patch \
@@ -19,7 +19,7 @@
 UPSTREAM_CHECK_URI = "http://sourceforge.net/projects/libjpeg-turbo/files/"
 UPSTREAM_CHECK_REGEX = "/libjpeg-turbo/files/(?P<pver>(\d+[\.\-_]*)+)/"
 
-PE= "1"
+PE = "1"
 
 # Drop-in replacement for jpeg
 PROVIDES = "jpeg"
diff --git a/poky/meta/recipes-graphics/mesa/mesa-gl_20.0.2.bb b/poky/meta/recipes-graphics/mesa/mesa-gl_20.0.7.bb
similarity index 96%
rename from poky/meta/recipes-graphics/mesa/mesa-gl_20.0.2.bb
rename to poky/meta/recipes-graphics/mesa/mesa-gl_20.0.7.bb
index c7897cd..e50782b 100644
--- a/poky/meta/recipes-graphics/mesa/mesa-gl_20.0.2.bb
+++ b/poky/meta/recipes-graphics/mesa/mesa-gl_20.0.7.bb
@@ -1,4 +1,4 @@
-require mesa_${PV}.bb
+require mesa.inc
 
 SUMMARY += " (OpenGL only, no EGL/GLES)"
 
diff --git a/poky/meta/recipes-graphics/mesa/mesa.inc b/poky/meta/recipes-graphics/mesa/mesa.inc
index bb43a9a..965e12d 100644
--- a/poky/meta/recipes-graphics/mesa/mesa.inc
+++ b/poky/meta/recipes-graphics/mesa/mesa.inc
@@ -14,6 +14,28 @@
 
 PE = "2"
 
+SRC_URI = "https://mesa.freedesktop.org/archive/mesa-${PV}.tar.xz \
+           file://0001-meson.build-check-for-all-linux-host_os-combinations.patch \
+           file://0002-meson.build-make-TLS-ELF-optional.patch \
+           file://0003-Allow-enable-DRI-without-DRI-drivers.patch \
+           file://0004-Revert-mesa-Enable-asm-unconditionally-now-that-gen_.patch \
+           file://0005-vc4-use-intmax_t-for-formatted-output-of-timespec-me.patch \
+           file://0001-meson-misdetects-64bit-atomics-on-mips-clang.patch \
+           "
+
+SRC_URI[md5sum] = "609cb7664204e031d4c65c602c652a28"
+SRC_URI[sha256sum] = "fe6e258fe772c3cd2ac01741bf7408058c3ac02d66acff9a6e669bd72e3ea178"
+
+UPSTREAM_CHECK_GITTAGREGEX = "mesa-(?P<pver>\d+(\.\d+)+)"
+
+#because we cannot rely on the fact that all apps will use pkgconfig,
+#make eglplatform.h independent of MESA_EGL_NO_X11_HEADER
+do_install_append() {
+    if ${@bb.utils.contains('PACKAGECONFIG', 'egl', 'true', 'false', d)}; then
+        sed -i -e 's/^#elif defined(__unix__) && defined(EGL_NO_X11)$/#elif defined(__unix__) \&\& defined(EGL_NO_X11) || ${@bb.utils.contains('PACKAGECONFIG', 'x11', '0', '1', d)}/' ${D}${includedir}/EGL/eglplatform.h
+    fi
+}
+
 DEPENDS = "expat makedepend-native flex-native bison-native libxml2-native zlib chrpath-replacement-native python3-mako-native gettext-native"
 EXTRANATIVEPATH += "chrpath-native"
 PROVIDES = " \
diff --git a/poky/meta/recipes-graphics/mesa/mesa_20.0.2.bb b/poky/meta/recipes-graphics/mesa/mesa_20.0.2.bb
deleted file mode 100644
index ee0260e..0000000
--- a/poky/meta/recipes-graphics/mesa/mesa_20.0.2.bb
+++ /dev/null
@@ -1,23 +0,0 @@
-require ${BPN}.inc
-
-SRC_URI = "https://mesa.freedesktop.org/archive/mesa-${PV}.tar.xz \
-           file://0001-meson.build-check-for-all-linux-host_os-combinations.patch \
-           file://0002-meson.build-make-TLS-ELF-optional.patch \
-           file://0003-Allow-enable-DRI-without-DRI-drivers.patch \
-           file://0004-Revert-mesa-Enable-asm-unconditionally-now-that-gen_.patch \
-           file://0005-vc4-use-intmax_t-for-formatted-output-of-timespec-me.patch \
-           file://0001-meson-misdetects-64bit-atomics-on-mips-clang.patch \
-           "
-
-SRC_URI[md5sum] = "31ca59cd92c38cb8e1a58b62b01c3e08"
-SRC_URI[sha256sum] = "aa54f1cb669550606aab8ceb475105d15aeb814fca5a778ce70d0fd10e98e86f"
-
-UPSTREAM_CHECK_GITTAGREGEX = "mesa-(?P<pver>\d+(\.\d+)+)"
-
-#because we cannot rely on the fact that all apps will use pkgconfig,
-#make eglplatform.h independent of MESA_EGL_NO_X11_HEADER
-do_install_append() {
-    if ${@bb.utils.contains('PACKAGECONFIG', 'egl', 'true', 'false', d)}; then
-        sed -i -e 's/^#elif defined(__unix__) && defined(EGL_NO_X11)$/#elif defined(__unix__) \&\& defined(EGL_NO_X11) || ${@bb.utils.contains('PACKAGECONFIG', 'x11', '0', '1', d)}/' ${D}${includedir}/EGL/eglplatform.h
-    fi
-}
diff --git a/poky/meta/recipes-graphics/mesa/mesa_20.0.7.bb b/poky/meta/recipes-graphics/mesa/mesa_20.0.7.bb
new file mode 100644
index 0000000..d17d9eb
--- /dev/null
+++ b/poky/meta/recipes-graphics/mesa/mesa_20.0.7.bb
@@ -0,0 +1 @@
+require ${BPN}.inc
diff --git a/poky/meta/recipes-graphics/piglit/piglit_git.bb b/poky/meta/recipes-graphics/piglit/piglit_git.bb
index 58d10d6..47950c8 100644
--- a/poky/meta/recipes-graphics/piglit/piglit_git.bb
+++ b/poky/meta/recipes-graphics/piglit/piglit_git.bb
@@ -10,7 +10,7 @@
            "
 UPSTREAM_CHECK_COMMITS = "1"
 
-SRCREV = "6126c2d4e476c7770d216ffa1932c10e2a5a7813"
+SRCREV = "5cc4fd749375f37e8e8725a86072d8cff7173b98"
 # (when PV goes above 1.0 remove the trailing r)
 PV = "1.0+gitr${SRCPV}"
 
diff --git a/poky/meta/recipes-graphics/waffle/waffle_1.6.0.bb b/poky/meta/recipes-graphics/waffle/waffle_1.6.1.bb
similarity index 92%
rename from poky/meta/recipes-graphics/waffle/waffle_1.6.0.bb
rename to poky/meta/recipes-graphics/waffle/waffle_1.6.1.bb
index a620295..3f3c0e9 100644
--- a/poky/meta/recipes-graphics/waffle/waffle_1.6.0.bb
+++ b/poky/meta/recipes-graphics/waffle/waffle_1.6.1.bb
@@ -4,8 +4,8 @@
                     file://include/waffle/waffle.h;endline=24;md5=61dbf8697f61c78645e75a93c585b1bf"
 
 SRC_URI = "http://waffle-gl.org/files/release/${BPN}-${PV}/${BPN}-${PV}.tar.xz"
-SRC_URI[md5sum] = "61bfc1a478e840825f33ddb4057115e7"
-SRC_URI[sha256sum] = "d9c899f710c50cfdd00f5f4cdfeaef0687d8497362239bdde93bed6c909c81d7"
+SRC_URI[md5sum] = "c91529e579483f44fb330052872b9c73"
+SRC_URI[sha256sum] = "31565649ff0e2d8dff1b8f7f2264ab7a78452063c7e04adfc4ce03e64b655080"
 
 UPSTREAM_CHECK_URI = "http://www.waffle-gl.org/releases.html"
 
diff --git a/poky/meta/recipes-graphics/xorg-driver/xf86-input-libinput_0.29.0.bb b/poky/meta/recipes-graphics/xorg-driver/xf86-input-libinput_0.30.0.bb
similarity index 63%
rename from poky/meta/recipes-graphics/xorg-driver/xf86-input-libinput_0.29.0.bb
rename to poky/meta/recipes-graphics/xorg-driver/xf86-input-libinput_0.30.0.bb
index f87083e..d02988c 100644
--- a/poky/meta/recipes-graphics/xorg-driver/xf86-input-libinput_0.29.0.bb
+++ b/poky/meta/recipes-graphics/xorg-driver/xf86-input-libinput_0.30.0.bb
@@ -5,7 +5,7 @@
 
 DEPENDS += "libinput"
 
-SRC_URI[md5sum] = "d600e8e2e30747b8ce49ec5294ff0ab6"
-SRC_URI[sha256sum] = "c28b56a21754b972db31798e6a4cf4dc9d69208d08f8fe41701a94def5e94bee"
+SRC_URI[md5sum] = "11dcfa2cc39f790731a9545fcdeea717"
+SRC_URI[sha256sum] = "f9c7f9fd41ae14061e0e9c3bd45fa170e5e21027a2bc5810034e1e748db996c0"
 
 FILES_${PN} += "${datadir}/X11/xorg.conf.d"
diff --git a/poky/meta/recipes-graphics/xorg-lib/libxt_1.2.0.bb b/poky/meta/recipes-graphics/xorg-lib/libxt_1.2.0.bb
index 42df435..5438452 100644
--- a/poky/meta/recipes-graphics/xorg-lib/libxt_1.2.0.bb
+++ b/poky/meta/recipes-graphics/xorg-lib/libxt_1.2.0.bb
@@ -22,8 +22,8 @@
 
 XORG_PN = "libXt"
 
-SRC_URI +=  "file://libxt_fix_for_x32.patch \
-            "
+SRC_URI += "file://libxt_fix_for_x32.patch"
+
 SRC_URI[md5sum] = "a9019421d3ee8b4937b6afd9025f018a"
 SRC_URI[sha256sum] = "b31df531dabed9f4611fc8980bc51d7782967e2aff44c4105251a1acb5a77831"
 
diff --git a/poky/meta/recipes-graphics/xorg-lib/pixman/0001-test-utils-Check-for-FE_INVALID-definition-before-us.patch b/poky/meta/recipes-graphics/xorg-lib/pixman/0001-test-utils-Check-for-FE_INVALID-definition-before-us.patch
deleted file mode 100644
index 23cbf53..0000000
--- a/poky/meta/recipes-graphics/xorg-lib/pixman/0001-test-utils-Check-for-FE_INVALID-definition-before-us.patch
+++ /dev/null
@@ -1,33 +0,0 @@
-From 0ccd906b904d21536d5ab41c6196760e3e5d72cb Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Tue, 17 May 2016 17:30:00 -0700
-Subject: [PATCH] test/utils: Check for FE_INVALID definition before use
-
-Some architectures e.g. nios2 do not support all exceptions
-
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
-Upstream-Status: Submitted [https://gitlab.freedesktop.org/pixman/pixman/merge_requests/24]
-
- test/utils.c | 2 ++
- 1 file changed, 2 insertions(+)
-
-diff --git a/test/utils.c b/test/utils.c
-index f8e42a5..fe32b1e 100644
---- a/test/utils.c
-+++ b/test/utils.c
-@@ -978,9 +978,11 @@ enable_invalid_exceptions (void)
- {
- #ifdef HAVE_FENV_H
- #ifdef HAVE_FEENABLEEXCEPT
-+#ifdef FE_INVALID
-     feenableexcept (FE_INVALID);
- #endif
- #endif
-+#endif
- }
- 
- void *
--- 
-2.8.2
-
diff --git a/poky/meta/recipes-graphics/xorg-lib/pixman_0.38.4.bb b/poky/meta/recipes-graphics/xorg-lib/pixman_0.40.0.bb
similarity index 85%
rename from poky/meta/recipes-graphics/xorg-lib/pixman_0.38.4.bb
rename to poky/meta/recipes-graphics/xorg-lib/pixman_0.40.0.bb
index 22e19ba..5a3bb22 100644
--- a/poky/meta/recipes-graphics/xorg-lib/pixman_0.38.4.bb
+++ b/poky/meta/recipes-graphics/xorg-lib/pixman_0.40.0.bb
@@ -9,10 +9,9 @@
 
 SRC_URI = "https://www.cairographics.org/releases/${BP}.tar.gz \
            file://0001-ARM-qemu-related-workarounds-in-cpu-features-detecti.patch \
-           file://0001-test-utils-Check-for-FE_INVALID-definition-before-us.patch \
            "
-SRC_URI[md5sum] = "267a7af290f93f643a1bc74490d9fdd1"
-SRC_URI[sha256sum] = "da66d6fd6e40aee70f7bd02e4f8f76fc3f006ec879d346bae6a723025cfbdde7"
+SRC_URI[md5sum] = "73858c0862dd9896fb5f62ae267084a4"
+SRC_URI[sha256sum] = "6d200dec3740d9ec4ec8d1180e25779c00bc749f94278c8b9021f5534db223fc"
 
 # see http://cairographics.org/releases/ - only even minor versions are stable
 UPSTREAM_CHECK_REGEX = "pixman-(?P<pver>\d+\.(\d*[02468])+(\.\d+)+)"
diff --git a/poky/meta/recipes-kernel/kmod/kmod.inc b/poky/meta/recipes-kernel/kmod/kmod.inc
index 3344538..b7c5cbe 100644
--- a/poky/meta/recipes-kernel/kmod/kmod.inc
+++ b/poky/meta/recipes-kernel/kmod/kmod.inc
@@ -14,15 +14,14 @@
                    "
 inherit autotools gtk-doc pkgconfig manpages
 
-SRCREV = "58133a96c894c043e48c74ddf0bfe8db90bac62f"
+SRCREV = "819a125ca756003dce2d11624035b7fb605a8e99"
 # Lookout for PV bump too when SRCREV is changed
-PV = "26"
+PV = "27"
 
 SRC_URI = "git://git.kernel.org/pub/scm/utils/kernel/kmod/kmod.git \
            file://depmod-search.conf \
-           file://0001-build-Stop-using-dolt.patch \
            file://avoid_parallel_tests.patch \
-          "
+           "
 
 S = "${WORKDIR}/git"
 
diff --git a/poky/meta/recipes-kernel/kmod/kmod/0001-build-Stop-using-dolt.patch b/poky/meta/recipes-kernel/kmod/kmod/0001-build-Stop-using-dolt.patch
deleted file mode 100644
index c915ad5..0000000
--- a/poky/meta/recipes-kernel/kmod/kmod/0001-build-Stop-using-dolt.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-From f8b8d7b330433511d19a936ddfc7b7d1af5490b5 Mon Sep 17 00:00:00 2001
-From: Adrian Bunk <bunk@kernel.org>
-Date: Wed, 20 Feb 2019 14:22:04 +0200
-Subject: build: Stop using dolt
-
-This does regress "make -12" from 0.7s to 0.9s on my
-Coffee Lake machine, but even on slower hardware this
-will not amount to a noticable slowdown.
-
-On the other hand using dolt can create problems for
-people doing cross-compilation, e.g. Yocto has two
-hacks just for dolt in kmod:
-https://git.yoctoproject.org/cgit/cgit.cgi/poky/tree/meta/recipes-kernel/kmod/kmod.inc?id=a17abae00785c76cfffe5381a22fb2c86b982e82
-
-Signed-off-by: Adrian Bunk <bunk@kernel.org>
-Upstream-Status: Backport
-
---- a/configure.ac
-+++ b/configure.ac
-@@ -17,7 +17,6 @@ AM_MAINTAINER_MODE([enable])
- AM_INIT_AUTOMAKE([check-news foreign 1.11 silent-rules tar-pax no-dist-gzip dist-xz subdir-objects color-tests parallel-tests])
- AM_SILENT_RULES([yes])
- LT_INIT([disable-static pic-only])
--DOLT
- 
- AS_IF([test "x$enable_static" = "xyes"], [AC_MSG_ERROR([--enable-static is not supported by kmod])])
- AS_IF([test "x$enable_largefile" = "xno"], [AC_MSG_ERROR([--disable-largefile is not supported by kmod])])
-
diff --git a/poky/meta/recipes-kernel/linux/linux-yocto-rt_5.4.bb b/poky/meta/recipes-kernel/linux/linux-yocto-rt_5.4.bb
index f6acb29..a9213c2 100644
--- a/poky/meta/recipes-kernel/linux/linux-yocto-rt_5.4.bb
+++ b/poky/meta/recipes-kernel/linux/linux-yocto-rt_5.4.bb
@@ -11,13 +11,13 @@
         raise bb.parse.SkipRecipe("Set PREFERRED_PROVIDER_virtual/kernel to linux-yocto-rt to enable it")
 }
 
-SRCREV_machine ?= "5db46f8cf9b485f320287147ce593789ee0b5447"
-SRCREV_meta ?= "4ed477131e6e508d335d70c070eb84a5c3d673e5"
+SRCREV_machine ?= "1afad41c91e13f957bbe61fa7fdc05a77e84d489"
+SRCREV_meta ?= "aafb8f095e97013d6e55b09ed150369cbe0c6476"
 
 SRC_URI = "git://git.yoctoproject.org/linux-yocto.git;branch=${KBRANCH};name=machine \
            git://git.yoctoproject.org/yocto-kernel-cache;type=kmeta;name=meta;branch=yocto-5.4;destsuffix=${KMETA}"
 
-LINUX_VERSION ?= "5.4.40"
+LINUX_VERSION ?= "5.4.43"
 
 LIC_FILES_CHKSUM = "file://COPYING;md5=bbea815ee2795b2f4230826c0c6b8814"
 
diff --git a/poky/meta/recipes-kernel/linux/linux-yocto-tiny_5.4.bb b/poky/meta/recipes-kernel/linux/linux-yocto-tiny_5.4.bb
index f797aa1..aab53be 100644
--- a/poky/meta/recipes-kernel/linux/linux-yocto-tiny_5.4.bb
+++ b/poky/meta/recipes-kernel/linux/linux-yocto-tiny_5.4.bb
@@ -6,7 +6,7 @@
 
 require recipes-kernel/linux/linux-yocto.inc
 
-LINUX_VERSION ?= "5.4.40"
+LINUX_VERSION ?= "5.4.43"
 LIC_FILES_CHKSUM = "file://COPYING;md5=bbea815ee2795b2f4230826c0c6b8814"
 
 DEPENDS += "${@bb.utils.contains('ARCH', 'x86', 'elfutils-native', '', d)}"
@@ -15,9 +15,9 @@
 KMETA = "kernel-meta"
 KCONF_BSP_AUDIT_LEVEL = "2"
 
-SRCREV_machine_qemuarm ?= "b84f9483ed29096cd9bb6b1922666e8a275dd496"
-SRCREV_machine ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_meta ?= "4ed477131e6e508d335d70c070eb84a5c3d673e5"
+SRCREV_machine_qemuarm ?= "c3864bf2906c5075305bf675c27788505ea93047"
+SRCREV_machine ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_meta ?= "aafb8f095e97013d6e55b09ed150369cbe0c6476"
 
 PV = "${LINUX_VERSION}+git${SRCPV}"
 
diff --git a/poky/meta/recipes-kernel/linux/linux-yocto_5.4.bb b/poky/meta/recipes-kernel/linux/linux-yocto_5.4.bb
index 65afdc3..01795e6 100644
--- a/poky/meta/recipes-kernel/linux/linux-yocto_5.4.bb
+++ b/poky/meta/recipes-kernel/linux/linux-yocto_5.4.bb
@@ -12,16 +12,16 @@
 KBRANCH_qemux86-64 ?= "v5.4/standard/base"
 KBRANCH_qemumips64 ?= "v5.4/standard/mti-malta64"
 
-SRCREV_machine_qemuarm ?= "cbe84f8dbb7fe4a67a337795d81cca735346f4c8"
-SRCREV_machine_qemuarm64 ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_machine_qemumips ?= "b0ad6cf1238ec97860a9e26a6da1aa431c5b96fb"
-SRCREV_machine_qemuppc ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_machine_qemuriscv64 ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_machine_qemux86 ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_machine_qemux86-64 ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_machine_qemumips64 ?= "5247564ab2b897a678ed0cd8fb2905c918fc64df"
-SRCREV_machine ?= "29f44c85c379c38f15e544828e7e77b3c008f378"
-SRCREV_meta ?= "4ed477131e6e508d335d70c070eb84a5c3d673e5"
+SRCREV_machine_qemuarm ?= "6c628db39bf48f7dd6cd95ae826bcaa18a56df1d"
+SRCREV_machine_qemuarm64 ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_machine_qemumips ?= "c0cd2937ae195344ece04663b30b2049427b3c57"
+SRCREV_machine_qemuppc ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_machine_qemuriscv64 ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_machine_qemux86 ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_machine_qemux86-64 ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_machine_qemumips64 ?= "6254ff1d776b75bc3d9c2c66c083fbc622091cd4"
+SRCREV_machine ?= "9e1b13d7f9d84f691fb9988c5f53c5ab62b8a5e9"
+SRCREV_meta ?= "aafb8f095e97013d6e55b09ed150369cbe0c6476"
 
 # remap qemuarm to qemuarma15 for the 5.4 kernel
 # KMACHINE_qemuarm ?= "qemuarma15"
@@ -30,7 +30,7 @@
            git://git.yoctoproject.org/yocto-kernel-cache;type=kmeta;name=meta;branch=yocto-5.4;destsuffix=${KMETA}"
 
 LIC_FILES_CHKSUM = "file://COPYING;md5=bbea815ee2795b2f4230826c0c6b8814"
-LINUX_VERSION ?= "5.4.40"
+LINUX_VERSION ?= "5.4.43"
 
 DEPENDS += "${@bb.utils.contains('ARCH', 'x86', 'elfutils-native', '', d)}"
 DEPENDS += "openssl-native util-linux-native"
diff --git a/poky/meta/recipes-kernel/lttng/babeltrace2_2.0.2.bb b/poky/meta/recipes-kernel/lttng/babeltrace2_2.0.2.bb
index 0791c65..7777f9b 100644
--- a/poky/meta/recipes-kernel/lttng/babeltrace2_2.0.2.bb
+++ b/poky/meta/recipes-kernel/lttng/babeltrace2_2.0.2.bb
@@ -7,7 +7,7 @@
 
 DEPENDS = "glib-2.0 util-linux popt bison-native flex-native"
 
-SRC_URI = "git://git.linuxfoundation.org/diamon/babeltrace.git;branch=stable-2.0 \
+SRC_URI = "git://git.efficios.com/babeltrace.git;branch=stable-2.0 \
 	   file://run-ptest \
 	   file://0001-tests-do-not-run-test-applications-from-.libs.patch \
            file://0001-Make-manpages-multilib-identical.patch \
diff --git a/poky/meta/recipes-kernel/lttng/babeltrace_1.5.8.bb b/poky/meta/recipes-kernel/lttng/babeltrace_1.5.8.bb
index 4d2492a..9e5d3a7 100644
--- a/poky/meta/recipes-kernel/lttng/babeltrace_1.5.8.bb
+++ b/poky/meta/recipes-kernel/lttng/babeltrace_1.5.8.bb
@@ -7,7 +7,7 @@
 
 DEPENDS = "glib-2.0 util-linux popt bison-native flex-native"
 
-SRC_URI = "git://git.linuxfoundation.org/diamon/babeltrace.git;branch=stable-1.5 \
+SRC_URI = "git://git.efficios.com/babeltrace.git;branch=stable-1.5 \
 	   file://run-ptest \
 	  "
 SRCREV = "054a54ae10b01a271afc4f19496c041b10fb414c"
diff --git a/poky/meta/recipes-kernel/make-mod-scripts/make-mod-scripts_1.0.bb b/poky/meta/recipes-kernel/make-mod-scripts/make-mod-scripts_1.0.bb
index 0be1422..c7edb20 100644
--- a/poky/meta/recipes-kernel/make-mod-scripts/make-mod-scripts_1.0.bb
+++ b/poky/meta/recipes-kernel/make-mod-scripts/make-mod-scripts_1.0.bb
@@ -23,7 +23,8 @@
 #
 do_configure() {
 	unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS
-	oe_runmake CC="${KERNEL_CC}" LD="${KERNEL_LD}" AR="${KERNEL_AR}" \
-	           -C ${STAGING_KERNEL_DIR} O=${STAGING_KERNEL_BUILDDIR} scripts prepare
-
+	for t in prepare scripts_basic scripts; do
+		oe_runmake CC="${KERNEL_CC}" LD="${KERNEL_LD}" AR="${KERNEL_AR}" \
+		-C ${STAGING_KERNEL_DIR} O=${STAGING_KERNEL_BUILDDIR} $t
+	done
 }
diff --git a/poky/meta/recipes-kernel/powertop/powertop_2.10.bb b/poky/meta/recipes-kernel/powertop/powertop_2.12.bb
similarity index 80%
rename from poky/meta/recipes-kernel/powertop/powertop_2.10.bb
rename to poky/meta/recipes-kernel/powertop/powertop_2.12.bb
index f1b0e92..f085d9b 100644
--- a/poky/meta/recipes-kernel/powertop/powertop_2.10.bb
+++ b/poky/meta/recipes-kernel/powertop/powertop_2.12.bb
@@ -2,18 +2,18 @@
 DESCRIPTION = "Linux tool to diagnose issues with power consumption and power management."
 HOMEPAGE = "https://01.org/powertop/"
 BUGTRACKER = "https://app.devzing.com/powertopbugs/bugzilla"
-DEPENDS = "ncurses libnl pciutils"
+DEPENDS = "ncurses libnl pciutils autoconf-archive"
 LICENSE = "GPLv2"
 LIC_FILES_CHKSUM = "file://COPYING;md5=12f884d2ae1ff87c09e5b7ccc2c4ca7e"
 
 SRC_URI = "git://github.com/fenrus75/powertop;protocol=https \
     file://0001-wakeup_xxx.h-include-limits.h.patch \
 "
-SRCREV = "e8765b5475b22b7a2b6e9e8a031c68a268a0b0b3"
+SRCREV = "6988eaaa5bbcfff1dd86f757006c6c48cec965c5"
 
 S = "${WORKDIR}/git"
 
-inherit autotools gettext pkgconfig
+inherit autotools gettext pkgconfig bash-completion
 
 # we do not want libncursesw if we can
 do_configure_prepend() {
@@ -22,6 +22,7 @@
     mkdir -p ${B}/src/tuning/
     echo "${PV}" > ${S}/version-long
     echo "${PV}" > ${S}/version-short
+    cp ${STAGING_DATADIR}/aclocal/ax_require_defined.m4 ${S}/m4/
 }
 
 inherit update-alternatives
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-Fix-alsa-sound-.h-for-external-programs.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-Fix-alsa-sound-.h-for-external-programs.patch
deleted file mode 100644
index 890650a..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-Fix-alsa-sound-.h-for-external-programs.patch
+++ /dev/null
@@ -1,7104 +0,0 @@
-From ae564665ec261cf104de499b1cdda3564070fc65 Mon Sep 17 00:00:00 2001
-From: Takashi Iwai <tiwai@suse.de>
-Date: Fri, 20 Dec 2019 15:46:48 +0100
-Subject: [PATCH] Fix alsa/sound/*.h for external programs
-
-The recent update of sound/*.h to sync with the latest Linus uapi
-files broke the build of alsa-tools programs.  These files used to be
-a modified version of Linux sound/* header files, so that they could
-be built without Linux headers.  The special prefix like __user and
-other things were worked around there.
-
-We may do that again, but a better approach is to fix those things in
-Linux kernel uapi side, while we keep the minimal workaround in
-alsa-lib such as the __u16 and co type definitions.
-
-This patch is such an attempt, namely:
-- Keep the original $LINUX/uapi/sound/*.h in include/sound/uapi
-  directory
-- The "fixes" are applied to some uapi headers, so that they don't
-  contain Linux-specific prefix and use of opaque struct like
-  snd_ctl_elem_id
-- The uapi headers are included indirectly from include/sound/*.h
-- Some headers have inclusion of type_compat.h for the Linux variable
-  types and prefixes
-- type_compat.h tries to use <linux/types.h> when __linux__ is
-  defined, instead of the own conflicting definitions
-
-The last type might need a bit more adjustment depending on the
-compiler, but it can be fixed locally without disturbing else.
-
-Signed-off-by: Takashi Iwai <tiwai@suse.de>
-
-Upstream-Status: Backport
-
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
-
----
- configure.ac                      |    3 +-
- include/sound/Makefile.am         |    6 +-
- include/sound/asequencer.h        |  613 +----------------
- include/sound/asoc.h              |  634 +-----------------
- include/sound/asound.h            | 1039 +----------------------------
- include/sound/asound_fm.h         |  136 +---
- include/sound/emu10k1.h           |  383 +----------
- include/sound/hdsp.h              |  113 +---
- include/sound/hdspm.h             |  234 +------
- include/sound/sb16_csp.h          |  124 +---
- include/sound/sscape_ioctl.h      |   22 +-
- include/sound/tlv.h               |  118 +---
- include/sound/type_compat.h       |   13 +
- include/sound/uapi/Makefile.am    |    6 +
- include/sound/uapi/asequencer.h   |  612 +++++++++++++++++
- include/sound/uapi/asoc.h         |  633 ++++++++++++++++++
- include/sound/uapi/asound.h       | 1038 ++++++++++++++++++++++++++++
- include/sound/uapi/asound_fm.h    |  135 ++++
- include/sound/uapi/emu10k1.h      |  395 +++++++++++
- include/sound/uapi/hdsp.h         |  109 +++
- include/sound/uapi/hdspm.h        |  230 +++++++
- include/sound/uapi/sb16_csp.h     |  123 ++++
- include/sound/uapi/sscape_ioctl.h |   21 +
- include/sound/uapi/tlv.h          |  117 ++++
- src/topology/tplg_local.h         |    3 +-
- 25 files changed, 3452 insertions(+), 3408 deletions(-)
- create mode 100644 include/sound/uapi/Makefile.am
- create mode 100644 include/sound/uapi/asequencer.h
- create mode 100644 include/sound/uapi/asoc.h
- create mode 100644 include/sound/uapi/asound.h
- create mode 100644 include/sound/uapi/asound_fm.h
- create mode 100644 include/sound/uapi/emu10k1.h
- create mode 100644 include/sound/uapi/hdsp.h
- create mode 100644 include/sound/uapi/hdspm.h
- create mode 100644 include/sound/uapi/sb16_csp.h
- create mode 100644 include/sound/uapi/sscape_ioctl.h
- create mode 100644 include/sound/uapi/tlv.h
-
-diff --git a/configure.ac b/configure.ac
-index 119ef600..886f87bc 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -707,7 +707,8 @@ if test ! -L "$srcdir"/include/alsa ; then
- fi
- 
- AC_OUTPUT(Makefile doc/Makefile doc/pictures/Makefile doc/doxygen.cfg \
--	  include/Makefile include/sound/Makefile src/Versions src/Makefile \
-+	  include/Makefile include/sound/Makefile include/sound/uapi/Makefile \
-+	  src/Versions src/Makefile \
-           src/control/Makefile src/mixer/Makefile \
- 	  src/pcm/Makefile src/pcm/scopes/Makefile \
- 	  src/rawmidi/Makefile src/timer/Makefile \
-diff --git a/include/sound/Makefile.am b/include/sound/Makefile.am
-index 99c42211..ccc7d273 100644
---- a/include/sound/Makefile.am
-+++ b/include/sound/Makefile.am
-@@ -1,7 +1,9 @@
-+SUBDIRS = uapi
-+
- alsasoundincludedir = ${includedir}/alsa/sound
- 
- alsasoundinclude_HEADERS = asound_fm.h hdsp.h hdspm.h sb16_csp.h \
--			   sscape_ioctl.h emu10k1.h type_compat.h \
--			   asoc.h tlv.h
-+			   sscape_ioctl.h emu10k1.h  asoc.h tlv.h \
-+			   type_compat.h
- 
- noinst_HEADERS = asound.h asequencer.h
-diff --git a/include/sound/asequencer.h b/include/sound/asequencer.h
-index a75e14ed..e539a77e 100644
---- a/include/sound/asequencer.h
-+++ b/include/sound/asequencer.h
-@@ -1,612 +1 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--/*
-- *  Main header file for the ALSA sequencer
-- *  Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
-- *            (c) 1998-1999 by Jaroslav Kysela <perex@perex.cz>
-- *
-- *
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-- *
-- */
--#ifndef _UAPI__SOUND_ASEQUENCER_H
--#define _UAPI__SOUND_ASEQUENCER_H
--
--#include <sound/asound.h>
--
--/** version of the sequencer */
--#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2)
--
--/**
-- * definition of sequencer event types
-- */
--
--/** system messages
-- * event data type = #snd_seq_result
-- */
--#define SNDRV_SEQ_EVENT_SYSTEM		0
--#define SNDRV_SEQ_EVENT_RESULT		1
--
--/** note messages (channel specific)
-- * event data type = #snd_seq_ev_note
-- */
--#define SNDRV_SEQ_EVENT_NOTE		5
--#define SNDRV_SEQ_EVENT_NOTEON		6
--#define SNDRV_SEQ_EVENT_NOTEOFF		7
--#define SNDRV_SEQ_EVENT_KEYPRESS	8
--	
--/** control messages (channel specific)
-- * event data type = #snd_seq_ev_ctrl
-- */
--#define SNDRV_SEQ_EVENT_CONTROLLER	10
--#define SNDRV_SEQ_EVENT_PGMCHANGE	11
--#define SNDRV_SEQ_EVENT_CHANPRESS	12
--#define SNDRV_SEQ_EVENT_PITCHBEND	13	/**< from -8192 to 8191 */
--#define SNDRV_SEQ_EVENT_CONTROL14	14	/**< 14 bit controller value */
--#define SNDRV_SEQ_EVENT_NONREGPARAM	15	/**< 14 bit NRPN address + 14 bit unsigned value */
--#define SNDRV_SEQ_EVENT_REGPARAM	16	/**< 14 bit RPN address + 14 bit unsigned value */
--
--/** synchronisation messages
-- * event data type = #snd_seq_ev_ctrl
-- */
--#define SNDRV_SEQ_EVENT_SONGPOS		20	/* Song Position Pointer with LSB and MSB values */
--#define SNDRV_SEQ_EVENT_SONGSEL		21	/* Song Select with song ID number */
--#define SNDRV_SEQ_EVENT_QFRAME		22	/* midi time code quarter frame */
--#define SNDRV_SEQ_EVENT_TIMESIGN	23	/* SMF Time Signature event */
--#define SNDRV_SEQ_EVENT_KEYSIGN		24	/* SMF Key Signature event */
--	        
--/** timer messages
-- * event data type = snd_seq_ev_queue_control
-- */
--#define SNDRV_SEQ_EVENT_START		30	/* midi Real Time Start message */
--#define SNDRV_SEQ_EVENT_CONTINUE	31	/* midi Real Time Continue message */
--#define SNDRV_SEQ_EVENT_STOP		32	/* midi Real Time Stop message */	
--#define	SNDRV_SEQ_EVENT_SETPOS_TICK	33	/* set tick queue position */
--#define SNDRV_SEQ_EVENT_SETPOS_TIME	34	/* set realtime queue position */
--#define SNDRV_SEQ_EVENT_TEMPO		35	/* (SMF) Tempo event */
--#define SNDRV_SEQ_EVENT_CLOCK		36	/* midi Real Time Clock message */
--#define SNDRV_SEQ_EVENT_TICK		37	/* midi Real Time Tick message */
--#define SNDRV_SEQ_EVENT_QUEUE_SKEW	38	/* skew queue tempo */
--
--/** others
-- * event data type = none
-- */
--#define SNDRV_SEQ_EVENT_TUNE_REQUEST	40	/* tune request */
--#define SNDRV_SEQ_EVENT_RESET		41	/* reset to power-on state */
--#define SNDRV_SEQ_EVENT_SENSING		42	/* "active sensing" event */
--
--/** echo back, kernel private messages
-- * event data type = any type
-- */
--#define SNDRV_SEQ_EVENT_ECHO		50	/* echo event */
--#define SNDRV_SEQ_EVENT_OSS		51	/* OSS raw event */
--
--/** system status messages (broadcast for subscribers)
-- * event data type = snd_seq_addr
-- */
--#define SNDRV_SEQ_EVENT_CLIENT_START	60	/* new client has connected */
--#define SNDRV_SEQ_EVENT_CLIENT_EXIT	61	/* client has left the system */
--#define SNDRV_SEQ_EVENT_CLIENT_CHANGE	62	/* client status/info has changed */
--#define SNDRV_SEQ_EVENT_PORT_START	63	/* new port was created */
--#define SNDRV_SEQ_EVENT_PORT_EXIT	64	/* port was deleted from system */
--#define SNDRV_SEQ_EVENT_PORT_CHANGE	65	/* port status/info has changed */
--
--/** port connection changes
-- * event data type = snd_seq_connect
-- */
--#define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED	66	/* ports connected */
--#define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67	/* ports disconnected */
--
--/* 70-89:  synthesizer events - obsoleted */
--
--/** user-defined events with fixed length
-- * event data type = any
-- */
--#define SNDRV_SEQ_EVENT_USR0		90
--#define SNDRV_SEQ_EVENT_USR1		91
--#define SNDRV_SEQ_EVENT_USR2		92
--#define SNDRV_SEQ_EVENT_USR3		93
--#define SNDRV_SEQ_EVENT_USR4		94
--#define SNDRV_SEQ_EVENT_USR5		95
--#define SNDRV_SEQ_EVENT_USR6		96
--#define SNDRV_SEQ_EVENT_USR7		97
--#define SNDRV_SEQ_EVENT_USR8		98
--#define SNDRV_SEQ_EVENT_USR9		99
--
--/* 100-118: instrument layer - obsoleted */
--/* 119-129: reserved */
--
--/* 130-139: variable length events
-- * event data type = snd_seq_ev_ext
-- * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set)
-- */
--#define SNDRV_SEQ_EVENT_SYSEX		130	/* system exclusive data (variable length) */
--#define SNDRV_SEQ_EVENT_BOUNCE		131	/* error event */
--/* 132-134: reserved */
--#define SNDRV_SEQ_EVENT_USR_VAR0	135
--#define SNDRV_SEQ_EVENT_USR_VAR1	136
--#define SNDRV_SEQ_EVENT_USR_VAR2	137
--#define SNDRV_SEQ_EVENT_USR_VAR3	138
--#define SNDRV_SEQ_EVENT_USR_VAR4	139
--
--/* 150-151: kernel events with quote - DO NOT use in user clients */
--#define SNDRV_SEQ_EVENT_KERNEL_ERROR	150
--#define SNDRV_SEQ_EVENT_KERNEL_QUOTE	151	/* obsolete */
--
--/* 152-191: reserved */
--
--/* 192-254: hardware specific events */
--
--/* 255: special event */
--#define SNDRV_SEQ_EVENT_NONE		255
--
--
--typedef unsigned char snd_seq_event_type_t;
--
--/** event address */
--struct snd_seq_addr {
--	unsigned char client;	/**< Client number:         0..255, 255 = broadcast to all clients */
--	unsigned char port;	/**< Port within client:    0..255, 255 = broadcast to all ports */
--};
--
--/** port connection */
--struct snd_seq_connect {
--	struct snd_seq_addr sender;
--	struct snd_seq_addr dest;
--};
--
--
--#define SNDRV_SEQ_ADDRESS_UNKNOWN	253	/* unknown source */
--#define SNDRV_SEQ_ADDRESS_SUBSCRIBERS	254	/* send event to all subscribed ports */
--#define SNDRV_SEQ_ADDRESS_BROADCAST	255	/* send event to all queues/clients/ports/channels */
--#define SNDRV_SEQ_QUEUE_DIRECT		253	/* direct dispatch */
--
--	/* event mode flag - NOTE: only 8 bits available! */
--#define SNDRV_SEQ_TIME_STAMP_TICK	(0<<0) /* timestamp in clock ticks */
--#define SNDRV_SEQ_TIME_STAMP_REAL	(1<<0) /* timestamp in real time */
--#define SNDRV_SEQ_TIME_STAMP_MASK	(1<<0)
--
--#define SNDRV_SEQ_TIME_MODE_ABS		(0<<1)	/* absolute timestamp */
--#define SNDRV_SEQ_TIME_MODE_REL		(1<<1)	/* relative to current time */
--#define SNDRV_SEQ_TIME_MODE_MASK	(1<<1)
--
--#define SNDRV_SEQ_EVENT_LENGTH_FIXED	(0<<2)	/* fixed event size */
--#define SNDRV_SEQ_EVENT_LENGTH_VARIABLE	(1<<2)	/* variable event size */
--#define SNDRV_SEQ_EVENT_LENGTH_VARUSR	(2<<2)	/* variable event size - user memory space */
--#define SNDRV_SEQ_EVENT_LENGTH_MASK	(3<<2)
--
--#define SNDRV_SEQ_PRIORITY_NORMAL	(0<<4)	/* normal priority */
--#define SNDRV_SEQ_PRIORITY_HIGH		(1<<4)	/* event should be processed before others */
--#define SNDRV_SEQ_PRIORITY_MASK		(1<<4)
--
--
--	/* note event */
--struct snd_seq_ev_note {
--	unsigned char channel;
--	unsigned char note;
--	unsigned char velocity;
--	unsigned char off_velocity;	/* only for SNDRV_SEQ_EVENT_NOTE */
--	unsigned int duration;		/* only for SNDRV_SEQ_EVENT_NOTE */
--};
--
--	/* controller event */
--struct snd_seq_ev_ctrl {
--	unsigned char channel;
--	unsigned char unused1, unused2, unused3;	/* pad */
--	unsigned int param;
--	signed int value;
--};
--
--	/* generic set of bytes (12x8 bit) */
--struct snd_seq_ev_raw8 {
--	unsigned char d[12];	/* 8 bit value */
--};
--
--	/* generic set of integers (3x32 bit) */
--struct snd_seq_ev_raw32 {
--	unsigned int d[3];	/* 32 bit value */
--};
--
--	/* external stored data */
--struct snd_seq_ev_ext {
--	unsigned int len;	/* length of data */
--	void *ptr;		/* pointer to data (note: maybe 64-bit) */
--} __attribute__((packed));
--
--struct snd_seq_result {
--	int event;		/* processed event type */
--	int result;
--};
--
--
--struct snd_seq_real_time {
--	unsigned int tv_sec;	/* seconds */
--	unsigned int tv_nsec;	/* nanoseconds */
--};
--
--typedef unsigned int snd_seq_tick_time_t;	/* midi ticks */
--
--union snd_seq_timestamp {
--	snd_seq_tick_time_t tick;
--	struct snd_seq_real_time time;
--};
--
--struct snd_seq_queue_skew {
--	unsigned int value;
--	unsigned int base;
--};
--
--	/* queue timer control */
--struct snd_seq_ev_queue_control {
--	unsigned char queue;			/* affected queue */
--	unsigned char pad[3];			/* reserved */
--	union {
--		signed int value;		/* affected value (e.g. tempo) */
--		union snd_seq_timestamp time;	/* time */
--		unsigned int position;		/* sync position */
--		struct snd_seq_queue_skew skew;
--		unsigned int d32[2];
--		unsigned char d8[8];
--	} param;
--};
--
--	/* quoted event - inside the kernel only */
--struct snd_seq_ev_quote {
--	struct snd_seq_addr origin;		/* original sender */
--	unsigned short value;		/* optional data */
--	struct snd_seq_event *event;		/* quoted event */
--} __attribute__((packed));
--
--
--	/* sequencer event */
--struct snd_seq_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 {				/* 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;
--};
--
--
--/*
-- * bounce event - stored as variable size data
-- */
--struct snd_seq_event_bounce {
--	int err;
--	struct snd_seq_event event;
--	/* external data follows here. */
--};
--
--
--	/* system information */
--struct snd_seq_system_info {
--	int queues;			/* maximum queues count */
--	int clients;			/* maximum clients count */
--	int ports;			/* maximum ports per client */
--	int channels;			/* maximum channels per port */
--	int cur_clients;		/* current clients */
--	int cur_queues;			/* current queues */
--	char reserved[24];
--};
--
--
--	/* system running information */
--struct snd_seq_running_info {
--	unsigned char client;		/* client id */
--	unsigned char big_endian;	/* 1 = big-endian */
--	unsigned char cpu_mode;		/* 4 = 32bit, 8 = 64bit */
--	unsigned char pad;		/* reserved */
--	unsigned char reserved[12];
--};
--
--
--	/* known client numbers */
--#define SNDRV_SEQ_CLIENT_SYSTEM		0
--	/* internal client numbers */
--#define SNDRV_SEQ_CLIENT_DUMMY		14	/* midi through */
--#define SNDRV_SEQ_CLIENT_OSS		15	/* oss sequencer emulator */
--
--
--	/* client types */
--typedef int __bitwise snd_seq_client_type_t;
--#define	NO_CLIENT	((__force snd_seq_client_type_t) 0)
--#define	USER_CLIENT	((__force snd_seq_client_type_t) 1)
--#define	KERNEL_CLIENT	((__force snd_seq_client_type_t) 2)
--                        
--	/* event filter flags */
--#define SNDRV_SEQ_FILTER_BROADCAST	(1<<0)	/* accept broadcast messages */
--#define SNDRV_SEQ_FILTER_MULTICAST	(1<<1)	/* accept multicast messages */
--#define SNDRV_SEQ_FILTER_BOUNCE		(1<<2)	/* accept bounce event in error */
--#define SNDRV_SEQ_FILTER_USE_EVENT	(1<<31)	/* use event filter */
--
--struct snd_seq_client_info {
--	int client;			/* client number to inquire */
--	snd_seq_client_type_t type;	/* client type */
--	char name[64];			/* client name */
--	unsigned int filter;		/* filter flags */
--	unsigned char multicast_filter[8]; /* multicast filter bitmap */
--	unsigned char event_filter[32];	/* event filter bitmap */
--	int num_ports;			/* RO: number of ports */
--	int event_lost;			/* number of lost events */
--	int card;			/* RO: card number[kernel] */
--	int pid;			/* RO: pid[user] */
--	char reserved[56];		/* for future use */
--};
--
--
--/* client pool size */
--struct snd_seq_client_pool {
--	int client;			/* client number to inquire */
--	int output_pool;		/* outgoing (write) pool size */
--	int input_pool;			/* incoming (read) pool size */
--	int output_room;		/* minimum free pool size for select/blocking mode */
--	int output_free;		/* unused size */
--	int input_free;			/* unused size */
--	char reserved[64];
--};
--
--
--/* Remove events by specified criteria */
--
--#define SNDRV_SEQ_REMOVE_INPUT		(1<<0)	/* Flush input queues */
--#define SNDRV_SEQ_REMOVE_OUTPUT		(1<<1)	/* Flush output queues */
--#define SNDRV_SEQ_REMOVE_DEST		(1<<2)	/* Restrict by destination q:client:port */
--#define SNDRV_SEQ_REMOVE_DEST_CHANNEL	(1<<3)	/* Restrict by channel */
--#define SNDRV_SEQ_REMOVE_TIME_BEFORE	(1<<4)	/* Restrict to before time */
--#define SNDRV_SEQ_REMOVE_TIME_AFTER	(1<<5)	/* Restrict to time or after */
--#define SNDRV_SEQ_REMOVE_TIME_TICK	(1<<6)	/* Time is in ticks */
--#define SNDRV_SEQ_REMOVE_EVENT_TYPE	(1<<7)	/* Restrict to event type */
--#define SNDRV_SEQ_REMOVE_IGNORE_OFF 	(1<<8)	/* Do not flush off events */
--#define SNDRV_SEQ_REMOVE_TAG_MATCH 	(1<<9)	/* Restrict to events with given tag */
--
--struct snd_seq_remove_events {
--	unsigned int  remove_mode;	/* Flags that determine what gets removed */
--
--	union snd_seq_timestamp time;
--
--	unsigned char queue;	/* Queue for REMOVE_DEST */
--	struct snd_seq_addr dest;	/* Address for REMOVE_DEST */
--	unsigned char channel;	/* Channel for REMOVE_DEST */
--
--	int  type;	/* For REMOVE_EVENT_TYPE */
--	char  tag;	/* Tag for REMOVE_TAG */
--
--	int  reserved[10];	/* To allow for future binary compatibility */
--
--};
--
--
--	/* known port numbers */
--#define SNDRV_SEQ_PORT_SYSTEM_TIMER	0
--#define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE	1
--
--	/* port capabilities (32 bits) */
--#define SNDRV_SEQ_PORT_CAP_READ		(1<<0)	/* readable from this port */
--#define SNDRV_SEQ_PORT_CAP_WRITE	(1<<1)	/* writable to this port */
--
--#define SNDRV_SEQ_PORT_CAP_SYNC_READ	(1<<2)
--#define SNDRV_SEQ_PORT_CAP_SYNC_WRITE	(1<<3)
--
--#define SNDRV_SEQ_PORT_CAP_DUPLEX	(1<<4)
--
--#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 */
--
--	/* port type */
--#define SNDRV_SEQ_PORT_TYPE_SPECIFIC	(1<<0)	/* hardware specific */
--#define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1)	/* generic MIDI device */
--#define SNDRV_SEQ_PORT_TYPE_MIDI_GM	(1<<2)	/* General MIDI compatible device */
--#define SNDRV_SEQ_PORT_TYPE_MIDI_GS	(1<<3)	/* GS compatible device */
--#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 */
--
--/* other standards...*/
--#define SNDRV_SEQ_PORT_TYPE_SYNTH	(1<<10)	/* Synth device (no MIDI compatible - direct wavetable) */
--#define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11)	/* Sampling device (support sample download) */
--#define SNDRV_SEQ_PORT_TYPE_SAMPLE	(1<<12)	/* Sampling device (sample can be downloaded at any time) */
--/*...*/
--#define SNDRV_SEQ_PORT_TYPE_HARDWARE	(1<<16)	/* driver for a hardware device */
--#define SNDRV_SEQ_PORT_TYPE_SOFTWARE	(1<<17)	/* implemented in software */
--#define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER	(1<<18)	/* generates sound */
--#define SNDRV_SEQ_PORT_TYPE_PORT	(1<<19)	/* connects to other device(s) */
--#define SNDRV_SEQ_PORT_TYPE_APPLICATION	(1<<20)	/* application (sequencer/editor) */
--
--/* misc. conditioning flags */
--#define SNDRV_SEQ_PORT_FLG_GIVEN_PORT	(1<<0)
--#define SNDRV_SEQ_PORT_FLG_TIMESTAMP	(1<<1)
--#define SNDRV_SEQ_PORT_FLG_TIME_REAL	(1<<2)
--
--struct snd_seq_port_info {
--	struct snd_seq_addr addr;	/* client/port numbers */
--	char name[64];			/* port name */
--
--	unsigned int capability;	/* port capability bits */
--	unsigned int type;		/* port type bits */
--	int midi_channels;		/* channels per MIDI port */
--	int midi_voices;		/* voices per MIDI port */
--	int synth_voices;		/* voices per SYNTH port */
--
--	int read_use;			/* R/O: subscribers for output (from this port) */
--	int write_use;			/* R/O: subscribers for input (to this port) */
--
--	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 */
--};
--
--
--/* queue flags */
--#define SNDRV_SEQ_QUEUE_FLG_SYNC	(1<<0)	/* sync enabled */
--
--/* queue information */
--struct snd_seq_queue_info {
--	int queue;		/* queue id */
--
--	/*
--	 *  security settings, only owner of this queue can start/stop timer
--	 *  etc. if the queue is locked for other clients
--	 */
--	int owner;		/* client id for owner of the queue */
--	unsigned locked:1;	/* timing queue locked for other queues */
--	char name[64];		/* name of this queue */
--	unsigned int flags;	/* flags */
--	char reserved[60];	/* for future use */
--
--};
--
--/* queue info/status */
--struct snd_seq_queue_status {
--	int queue;			/* queue id */
--	int events;			/* read-only - queue size */
--	snd_seq_tick_time_t tick;	/* current tick */
--	struct snd_seq_real_time time;	/* current time */
--	int running;			/* running state of queue */
--	int flags;			/* various flags */
--	char reserved[64];		/* for the future */
--};
--
--
--/* queue tempo */
--struct snd_seq_queue_tempo {
--	int queue;			/* sequencer queue */
--	unsigned int tempo;		/* current tempo, us/tick */
--	int ppq;			/* time resolution, ticks/quarter */
--	unsigned int skew_value;	/* queue skew */
--	unsigned int skew_base;		/* queue skew base */
--	char reserved[24];		/* for the future */
--};
--
--
--/* sequencer timer sources */
--#define SNDRV_SEQ_TIMER_ALSA		0	/* ALSA timer */
--#define SNDRV_SEQ_TIMER_MIDI_CLOCK	1	/* Midi Clock (CLOCK event) */
--#define SNDRV_SEQ_TIMER_MIDI_TICK	2	/* Midi Timer Tick (TICK event) */
--
--/* queue timer info */
--struct snd_seq_queue_timer {
--	int queue;			/* sequencer queue */
--	int type;			/* source timer type */
--	union {
--		struct {
--			struct snd_timer_id id;	/* ALSA's timer ID */
--			unsigned int resolution;	/* resolution in Hz */
--		} alsa;
--	} u;
--	char reserved[64];		/* for the future use */
--};
--
--
--struct snd_seq_queue_client {
--	int queue;		/* sequencer queue */
--	int client;		/* sequencer client */
--	int used;		/* queue is used with this client
--				   (must be set for accepting events) */
--	/* per client watermarks */
--	char reserved[64];	/* for future use */
--};
--
--
--#define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE	(1<<0)	/* exclusive connection */
--#define SNDRV_SEQ_PORT_SUBS_TIMESTAMP	(1<<1)
--#define SNDRV_SEQ_PORT_SUBS_TIME_REAL	(1<<2)
--
--struct snd_seq_port_subscribe {
--	struct snd_seq_addr sender;	/* sender address */
--	struct snd_seq_addr dest;	/* destination address */
--	unsigned int voices;		/* number of voices to be allocated (0 = don't care) */
--	unsigned int flags;		/* modes */
--	unsigned char queue;		/* input time-stamp queue (optional) */
--	unsigned char pad[3];		/* reserved */
--	char reserved[64];
--};
--
--/* type of query subscription */
--#define SNDRV_SEQ_QUERY_SUBS_READ	0
--#define SNDRV_SEQ_QUERY_SUBS_WRITE	1
--
--struct snd_seq_query_subs {
--	struct snd_seq_addr root;	/* client/port id to be searched */
--	int type;		/* READ or WRITE */
--	int index;		/* 0..N-1 */
--	int num_subs;		/* R/O: number of subscriptions on this port */
--	struct snd_seq_addr addr;	/* R/O: result */
--	unsigned char queue;	/* R/O: result */
--	unsigned int flags;	/* R/O: result */
--	char reserved[64];	/* for future use */
--};
--
--
--/*
-- *  IOCTL commands
-- */
--
--#define SNDRV_SEQ_IOCTL_PVERSION	_IOR ('S', 0x00, int)
--#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_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_CREATE_PORT	_IOWR('S', 0x20, struct snd_seq_port_info)
--#define SNDRV_SEQ_IOCTL_DELETE_PORT	_IOW ('S', 0x21, struct snd_seq_port_info)
--#define SNDRV_SEQ_IOCTL_GET_PORT_INFO	_IOWR('S', 0x22, struct snd_seq_port_info)
--#define SNDRV_SEQ_IOCTL_SET_PORT_INFO	_IOW ('S', 0x23, struct snd_seq_port_info)
--
--#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT	_IOW ('S', 0x30, struct snd_seq_port_subscribe)
--#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe)
--
--#define SNDRV_SEQ_IOCTL_CREATE_QUEUE	_IOWR('S', 0x32, struct snd_seq_queue_info)
--#define SNDRV_SEQ_IOCTL_DELETE_QUEUE	_IOW ('S', 0x33, struct snd_seq_queue_info)
--#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO	_IOWR('S', 0x34, struct snd_seq_queue_info)
--#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO	_IOWR('S', 0x35, struct snd_seq_queue_info)
--#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE	_IOWR('S', 0x36, struct snd_seq_queue_info)
--#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status)
--#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO	_IOWR('S', 0x41, struct snd_seq_queue_tempo)
--#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO	_IOW ('S', 0x42, struct snd_seq_queue_tempo)
--#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER	_IOWR('S', 0x45, struct snd_seq_queue_timer)
--#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER	_IOW ('S', 0x46, struct snd_seq_queue_timer)
--#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT	_IOWR('S', 0x49, struct snd_seq_queue_client)
--#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT	_IOW ('S', 0x4a, struct snd_seq_queue_client)
--#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL	_IOWR('S', 0x4b, struct snd_seq_client_pool)
--#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL	_IOW ('S', 0x4c, struct snd_seq_client_pool)
--#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS	_IOW ('S', 0x4e, struct snd_seq_remove_events)
--#define SNDRV_SEQ_IOCTL_QUERY_SUBS	_IOWR('S', 0x4f, struct snd_seq_query_subs)
--#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION	_IOWR('S', 0x50, struct snd_seq_port_subscribe)
--#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT	_IOWR('S', 0x51, struct snd_seq_client_info)
--#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT	_IOWR('S', 0x52, struct snd_seq_port_info)
--
--#endif /* _UAPI__SOUND_ASEQUENCER_H */
-+#include <alsa/sound/uapi/asequencer.h>
-diff --git a/include/sound/asoc.h b/include/sound/asoc.h
-index a74ca232..185bba81 100644
---- a/include/sound/asoc.h
-+++ b/include/sound/asoc.h
-@@ -1,633 +1 @@
--/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
--/*
-- * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM
-- *
-- * Copyright (C) 2012 Texas Instruments Inc.
-- * Copyright (C) 2015 Intel Corporation.
-- *
-- * This program is free software; you can redistribute it and/or modify
-- * it under the terms of the GNU General Public License version 2 as
-- * published by the Free Software Foundation.
-- *
-- * Simple file API to load FW that includes mixers, coefficients, DAPM graphs,
-- * algorithms, equalisers, DAIs, widgets etc.
--*/
--
--#ifndef __LINUX_UAPI_SND_ASOC_H
--#define __LINUX_UAPI_SND_ASOC_H
--
--#include <linux/types.h>
--#include <sound/asound.h>
--
--/*
-- * Maximum number of channels topology kcontrol can represent.
-- */
--#define SND_SOC_TPLG_MAX_CHAN		8
--
--/*
-- * Maximum number of PCM formats capability
-- */
--#define SND_SOC_TPLG_MAX_FORMATS	16
--
--/*
-- * Maximum number of PCM stream configs
-- */
--#define SND_SOC_TPLG_STREAM_CONFIG_MAX  8
--
--/*
-- * Maximum number of physical link's hardware configs
-- */
--#define SND_SOC_TPLG_HW_CONFIG_MAX	8
--
--/* individual kcontrol info types - can be mixed with other types */
--#define SND_SOC_TPLG_CTL_VOLSW		1
--#define SND_SOC_TPLG_CTL_VOLSW_SX	2
--#define SND_SOC_TPLG_CTL_VOLSW_XR_SX	3
--#define SND_SOC_TPLG_CTL_ENUM		4
--#define SND_SOC_TPLG_CTL_BYTES		5
--#define SND_SOC_TPLG_CTL_ENUM_VALUE	6
--#define SND_SOC_TPLG_CTL_RANGE		7
--#define SND_SOC_TPLG_CTL_STROBE		8
--
--
--/* individual widget kcontrol info types - can be mixed with other types */
--#define SND_SOC_TPLG_DAPM_CTL_VOLSW		64
--#define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE	65
--#define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT		66
--#define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE	67
--#define SND_SOC_TPLG_DAPM_CTL_PIN		68
--
--/* DAPM widget types - add new items to the end */
--#define SND_SOC_TPLG_DAPM_INPUT		0
--#define SND_SOC_TPLG_DAPM_OUTPUT	1
--#define SND_SOC_TPLG_DAPM_MUX		2
--#define SND_SOC_TPLG_DAPM_MIXER		3
--#define SND_SOC_TPLG_DAPM_PGA		4
--#define SND_SOC_TPLG_DAPM_OUT_DRV	5
--#define SND_SOC_TPLG_DAPM_ADC		6
--#define SND_SOC_TPLG_DAPM_DAC		7
--#define SND_SOC_TPLG_DAPM_SWITCH	8
--#define SND_SOC_TPLG_DAPM_PRE		9
--#define SND_SOC_TPLG_DAPM_POST		10
--#define SND_SOC_TPLG_DAPM_AIF_IN	11
--#define SND_SOC_TPLG_DAPM_AIF_OUT	12
--#define SND_SOC_TPLG_DAPM_DAI_IN	13
--#define SND_SOC_TPLG_DAPM_DAI_OUT	14
--#define SND_SOC_TPLG_DAPM_DAI_LINK	15
--#define SND_SOC_TPLG_DAPM_BUFFER	16
--#define SND_SOC_TPLG_DAPM_SCHEDULER	17
--#define SND_SOC_TPLG_DAPM_EFFECT	18
--#define SND_SOC_TPLG_DAPM_SIGGEN	19
--#define SND_SOC_TPLG_DAPM_SRC		20
--#define SND_SOC_TPLG_DAPM_ASRC		21
--#define SND_SOC_TPLG_DAPM_ENCODER	22
--#define SND_SOC_TPLG_DAPM_DECODER	23
--#define SND_SOC_TPLG_DAPM_LAST		SND_SOC_TPLG_DAPM_DECODER
--
--/* Header magic number and string sizes */
--#define SND_SOC_TPLG_MAGIC		0x41536F43 /* ASoC */
--
--/* string sizes */
--#define SND_SOC_TPLG_NUM_TEXTS		16
--
--/* ABI version */
--#define SND_SOC_TPLG_ABI_VERSION	0x5	/* current version */
--#define SND_SOC_TPLG_ABI_VERSION_MIN	0x4	/* oldest version supported */
--
--/* Max size of TLV data */
--#define SND_SOC_TPLG_TLV_SIZE		32
--
--/*
-- * File and Block header data types.
-- * Add new generic and vendor types to end of list.
-- * Generic types are handled by the core whilst vendors types are passed
-- * to the component drivers for handling.
-- */
--#define SND_SOC_TPLG_TYPE_MIXER		1
--#define SND_SOC_TPLG_TYPE_BYTES		2
--#define SND_SOC_TPLG_TYPE_ENUM		3
--#define SND_SOC_TPLG_TYPE_DAPM_GRAPH	4
--#define SND_SOC_TPLG_TYPE_DAPM_WIDGET	5
--#define SND_SOC_TPLG_TYPE_DAI_LINK	6
--#define SND_SOC_TPLG_TYPE_PCM		7
--#define SND_SOC_TPLG_TYPE_MANIFEST	8
--#define SND_SOC_TPLG_TYPE_CODEC_LINK	9
--#define SND_SOC_TPLG_TYPE_BACKEND_LINK	10
--#define SND_SOC_TPLG_TYPE_PDATA		11
--#define SND_SOC_TPLG_TYPE_DAI		12
--#define SND_SOC_TPLG_TYPE_MAX		SND_SOC_TPLG_TYPE_DAI
--
--/* vendor block IDs - please add new vendor types to end */
--#define SND_SOC_TPLG_TYPE_VENDOR_FW	1000
--#define SND_SOC_TPLG_TYPE_VENDOR_CONFIG	1001
--#define SND_SOC_TPLG_TYPE_VENDOR_COEFF	1002
--#define SND_SOC_TPLG_TYPEVENDOR_CODEC	1003
--
--#define SND_SOC_TPLG_STREAM_PLAYBACK	0
--#define SND_SOC_TPLG_STREAM_CAPTURE	1
--
--/* vendor tuple types */
--#define SND_SOC_TPLG_TUPLE_TYPE_UUID	0
--#define SND_SOC_TPLG_TUPLE_TYPE_STRING	1
--#define SND_SOC_TPLG_TUPLE_TYPE_BOOL	2
--#define SND_SOC_TPLG_TUPLE_TYPE_BYTE	3
--#define SND_SOC_TPLG_TUPLE_TYPE_WORD	4
--#define SND_SOC_TPLG_TUPLE_TYPE_SHORT	5
--
--/* DAI flags */
--#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES         (1 << 0)
--#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS      (1 << 1)
--#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS    (1 << 2)
--
--/* DAI clock gating */
--#define SND_SOC_TPLG_DAI_CLK_GATE_UNDEFINED	0
--#define SND_SOC_TPLG_DAI_CLK_GATE_GATED	1
--#define SND_SOC_TPLG_DAI_CLK_GATE_CONT		2
--
--/* DAI mclk_direction */
--#define SND_SOC_TPLG_MCLK_CO            0 /* for codec, mclk is output */
--#define SND_SOC_TPLG_MCLK_CI            1 /* for codec, mclk is input */
--
--/* DAI physical PCM data formats.
-- * Add new formats to the end of the list.
-- */
--#define SND_SOC_DAI_FORMAT_I2S          1 /* I2S mode */
--#define SND_SOC_DAI_FORMAT_RIGHT_J      2 /* Right Justified mode */
--#define SND_SOC_DAI_FORMAT_LEFT_J       3 /* Left Justified mode */
--#define SND_SOC_DAI_FORMAT_DSP_A        4 /* L data MSB after FRM LRC */
--#define SND_SOC_DAI_FORMAT_DSP_B        5 /* L data MSB during FRM LRC */
--#define SND_SOC_DAI_FORMAT_AC97         6 /* AC97 */
--#define SND_SOC_DAI_FORMAT_PDM          7 /* Pulse density modulation */
--
--/* left and right justified also known as MSB and LSB respectively */
--#define SND_SOC_DAI_FORMAT_MSB          SND_SOC_DAI_FORMAT_LEFT_J
--#define SND_SOC_DAI_FORMAT_LSB          SND_SOC_DAI_FORMAT_RIGHT_J
--
--/* DAI link flags */
--#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES         (1 << 0)
--#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS      (1 << 1)
--#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS    (1 << 2)
--#define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP            (1 << 3)
--
--/* DAI topology BCLK parameter
-- * For the backwards capability, by default codec is bclk master
-- */
--#define SND_SOC_TPLG_BCLK_CM         0 /* codec is bclk master */
--#define SND_SOC_TPLG_BCLK_CS         1 /* codec is bclk slave */
--
--/* DAI topology FSYNC parameter
-- * For the backwards capability, by default codec is fsync master
-- */
--#define SND_SOC_TPLG_FSYNC_CM         0 /* codec is fsync master */
--#define SND_SOC_TPLG_FSYNC_CS         1 /* codec is fsync slave */
--
--/*
-- * Block Header.
-- * This header precedes all object and object arrays below.
-- */
--struct snd_soc_tplg_hdr {
--	__le32 magic;		/* magic number */
--	__le32 abi;		/* ABI version */
--	__le32 version;		/* optional vendor specific version details */
--	__le32 type;		/* SND_SOC_TPLG_TYPE_ */
--	__le32 size;		/* size of this structure */
--	__le32 vendor_type;	/* optional vendor specific type info */
--	__le32 payload_size;	/* data bytes, excluding this header */
--	__le32 index;		/* identifier for block */
--	__le32 count;		/* number of elements in block */
--} __attribute__((packed));
--
--/* vendor tuple for uuid */
--struct snd_soc_tplg_vendor_uuid_elem {
--	__le32 token;
--	char uuid[16];
--} __attribute__((packed));
--
--/* vendor tuple for a bool/byte/short/word value */
--struct snd_soc_tplg_vendor_value_elem {
--	__le32 token;
--	__le32 value;
--} __attribute__((packed));
--
--/* vendor tuple for string */
--struct snd_soc_tplg_vendor_string_elem {
--	__le32 token;
--	char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--} __attribute__((packed));
--
--struct snd_soc_tplg_vendor_array {
--	__le32 size;	/* size in bytes of the array, including all elements */
--	__le32 type;	/* SND_SOC_TPLG_TUPLE_TYPE_ */
--	__le32 num_elems;	/* number of elements in array */
--	union {
--		struct snd_soc_tplg_vendor_uuid_elem uuid[0];
--		struct snd_soc_tplg_vendor_value_elem value[0];
--		struct snd_soc_tplg_vendor_string_elem string[0];
--	};
--} __attribute__((packed));
--
--/*
-- * Private data.
-- * All topology objects may have private data that can be used by the driver or
-- * firmware. Core will ignore this data.
-- */
--struct snd_soc_tplg_private {
--	__le32 size;	/* in bytes of private data */
--	union {
--		char data[0];
--		struct snd_soc_tplg_vendor_array array[0];
--	};
--} __attribute__((packed));
--
--/*
-- * Kcontrol TLV data.
-- */
--struct snd_soc_tplg_tlv_dbscale {
--	__le32 min;
--	__le32 step;
--	__le32 mute;
--} __attribute__((packed));
--
--struct snd_soc_tplg_ctl_tlv {
--	__le32 size;	/* in bytes of this structure */
--	__le32 type;	/* SNDRV_CTL_TLVT_*, type of TLV */
--	union {
--		__le32 data[SND_SOC_TPLG_TLV_SIZE];
--		struct snd_soc_tplg_tlv_dbscale scale;
--	};
--} __attribute__((packed));
--
--/*
-- * Kcontrol channel data
-- */
--struct snd_soc_tplg_channel {
--	__le32 size;	/* in bytes of this structure */
--	__le32 reg;
--	__le32 shift;
--	__le32 id;	/* ID maps to Left, Right, LFE etc */
--} __attribute__((packed));
--
--/*
-- * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops
-- * Kcontrol ops need get/put/info.
-- * Bytes ext ops need get/put.
-- */
--struct snd_soc_tplg_io_ops {
--	__le32 get;
--	__le32 put;
--	__le32 info;
--} __attribute__((packed));
--
--/*
-- * kcontrol header
-- */
--struct snd_soc_tplg_ctl_hdr {
--	__le32 size;	/* in bytes of this structure */
--	__le32 type;
--	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	__le32 access;
--	struct snd_soc_tplg_io_ops ops;
--	struct snd_soc_tplg_ctl_tlv tlv;
--} __attribute__((packed));
--
--/*
-- * Stream Capabilities
-- */
--struct snd_soc_tplg_stream_caps {
--	__le32 size;		/* in bytes of this structure */
--	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	__le64 formats;	/* supported formats SNDRV_PCM_FMTBIT_* */
--	__le32 rates;		/* supported rates SNDRV_PCM_RATE_* */
--	__le32 rate_min;	/* min rate */
--	__le32 rate_max;	/* max rate */
--	__le32 channels_min;	/* min channels */
--	__le32 channels_max;	/* max channels */
--	__le32 periods_min;	/* min number of periods */
--	__le32 periods_max;	/* max number of periods */
--	__le32 period_size_min;	/* min period size bytes */
--	__le32 period_size_max;	/* max period size bytes */
--	__le32 buffer_size_min;	/* min buffer size bytes */
--	__le32 buffer_size_max;	/* max buffer size bytes */
--	__le32 sig_bits;        /* number of bits of content */
--} __attribute__((packed));
--
--/*
-- * FE or BE Stream configuration supported by SW/FW
-- */
--struct snd_soc_tplg_stream {
--	__le32 size;		/* in bytes of this structure */
--	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* Name of the stream */
--	__le64 format;		/* SNDRV_PCM_FMTBIT_* */
--	__le32 rate;		/* SNDRV_PCM_RATE_* */
--	__le32 period_bytes;	/* size of period in bytes */
--	__le32 buffer_bytes;	/* size of buffer in bytes */
--	__le32 channels;	/* channels */
--} __attribute__((packed));
--
--
--/*
-- * Describes a physical link's runtime supported hardware config,
-- * i.e. hardware audio formats.
-- */
--struct snd_soc_tplg_hw_config {
--	__le32 size;            /* in bytes of this structure */
--	__le32 id;		/* unique ID - - used to match */
--	__le32 fmt;		/* SND_SOC_DAI_FORMAT_ format value */
--	__u8 clock_gated;	/* SND_SOC_TPLG_DAI_CLK_GATE_ value */
--	__u8 invert_bclk;	/* 1 for inverted BCLK, 0 for normal */
--	__u8 invert_fsync;	/* 1 for inverted frame clock, 0 for normal */
--	__u8 bclk_master;	/* SND_SOC_TPLG_BCLK_ value */
--	__u8 fsync_master;	/* SND_SOC_TPLG_FSYNC_ value */
--	__u8 mclk_direction;    /* SND_SOC_TPLG_MCLK_ value */
--	__le16 reserved;	/* for 32bit alignment */
--	__le32 mclk_rate;	/* MCLK or SYSCLK freqency in Hz */
--	__le32 bclk_rate;	/* BCLK freqency in Hz */
--	__le32 fsync_rate;	/* frame clock in Hz */
--	__le32 tdm_slots;	/* number of TDM slots in use */
--	__le32 tdm_slot_width;	/* width in bits for each slot */
--	__le32 tx_slots;	/* bit mask for active Tx slots */
--	__le32 rx_slots;	/* bit mask for active Rx slots */
--	__le32 tx_channels;	/* number of Tx channels */
--	__le32 tx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */
--	__le32 rx_channels;	/* number of Rx channels */
--	__le32 rx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */
--} __attribute__((packed));
--
--/*
-- * Manifest. List totals for each payload type. Not used in parsing, but will
-- * be passed to the component driver before any other objects in order for any
-- * global component resource allocations.
-- *
-- * File block representation for manifest :-
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_hdr           |  1 |
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_manifest      |  1 |
-- * +-----------------------------------+----+
-- */
--struct snd_soc_tplg_manifest {
--	__le32 size;		/* in bytes of this structure */
--	__le32 control_elems;	/* number of control elements */
--	__le32 widget_elems;	/* number of widget elements */
--	__le32 graph_elems;	/* number of graph elements */
--	__le32 pcm_elems;	/* number of PCM elements */
--	__le32 dai_link_elems;	/* number of DAI link elements */
--	__le32 dai_elems;	/* number of physical DAI elements */
--	__le32 reserved[20];	/* reserved for new ABI element types */
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--/*
-- * Mixer kcontrol.
-- *
-- * File block representation for mixer kcontrol :-
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_hdr           |  1 |
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_mixer_control |  N |
-- * +-----------------------------------+----+
-- */
--struct snd_soc_tplg_mixer_control {
--	struct snd_soc_tplg_ctl_hdr hdr;
--	__le32 size;	/* in bytes of this structure */
--	__le32 min;
--	__le32 max;
--	__le32 platform_max;
--	__le32 invert;
--	__le32 num_channels;
--	struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN];
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--/*
-- * Enumerated kcontrol
-- *
-- * File block representation for enum kcontrol :-
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_hdr           |  1 |
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_enum_control  |  N |
-- * +-----------------------------------+----+
-- */
--struct snd_soc_tplg_enum_control {
--	struct snd_soc_tplg_ctl_hdr hdr;
--	__le32 size;	/* in bytes of this structure */
--	__le32 num_channels;
--	struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN];
--	__le32 items;
--	__le32 mask;
--	__le32 count;
--	char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	__le32 values[SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4];
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--/*
-- * Bytes kcontrol
-- *
-- * File block representation for bytes kcontrol :-
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_hdr           |  1 |
-- * +-----------------------------------+----+
-- * | struct snd_soc_tplg_bytes_control |  N |
-- * +-----------------------------------+----+
-- */
--struct snd_soc_tplg_bytes_control {
--	struct snd_soc_tplg_ctl_hdr hdr;
--	__le32 size;	/* in bytes of this structure */
--	__le32 max;
--	__le32 mask;
--	__le32 base;
--	__le32 num_regs;
--	struct snd_soc_tplg_io_ops ext_ops;
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--/*
-- * DAPM Graph Element
-- *
-- * File block representation for DAPM graph elements :-
-- * +-------------------------------------+----+
-- * | struct snd_soc_tplg_hdr             |  1 |
-- * +-------------------------------------+----+
-- * | struct snd_soc_tplg_dapm_graph_elem |  N |
-- * +-------------------------------------+----+
-- */
--struct snd_soc_tplg_dapm_graph_elem {
--	char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--} __attribute__((packed));
--
--/*
-- * DAPM Widget.
-- *
-- * File block representation for DAPM widget :-
-- * +-------------------------------------+-----+
-- * | struct snd_soc_tplg_hdr             |  1  |
-- * +-------------------------------------+-----+
-- * | struct snd_soc_tplg_dapm_widget     |  N  |
-- * +-------------------------------------+-----+
-- * |   struct snd_soc_tplg_enum_control  | 0|1 |
-- * |   struct snd_soc_tplg_mixer_control | 0|N |
-- * +-------------------------------------+-----+
-- *
-- * Optional enum or mixer control can be appended to the end of each widget
-- * in the block.
-- */
--struct snd_soc_tplg_dapm_widget {
--	__le32 size;		/* in bytes of this structure */
--	__le32 id;		/* SND_SOC_DAPM_CTL */
--	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--
--	__le32 reg;		/* negative reg = no direct dapm */
--	__le32 shift;		/* bits to shift */
--	__le32 mask;		/* non-shifted mask */
--	__le32 subseq;		/* sort within widget type */
--	__le32 invert;		/* invert the power bit */
--	__le32 ignore_suspend;	/* kept enabled over suspend */
--	__le16 event_flags;
--	__le16 event_type;
--	__le32 num_kcontrols;
--	struct snd_soc_tplg_private priv;
--	/*
--	 * kcontrols that relate to this widget
--	 * follow here after widget private data
--	 */
--} __attribute__((packed));
--
--
--/*
-- * Describes SW/FW specific features of PCM (FE DAI & DAI link).
-- *
-- * File block representation for PCM :-
-- * +-----------------------------------+-----+
-- * | struct snd_soc_tplg_hdr           |  1  |
-- * +-----------------------------------+-----+
-- * | struct snd_soc_tplg_pcm           |  N  |
-- * +-----------------------------------+-----+
-- */
--struct snd_soc_tplg_pcm {
--	__le32 size;		/* in bytes of this structure */
--	char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	__le32 pcm_id;		/* unique ID - used to match with DAI link */
--	__le32 dai_id;		/* unique ID - used to match */
--	__le32 playback;	/* supports playback mode */
--	__le32 capture;		/* supports capture mode */
--	__le32 compress;	/* 1 = compressed; 0 = PCM */
--	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */
--	__le32 num_streams;	/* number of streams */
--	struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */
--	__le32 flag_mask;       /* bitmask of flags to configure */
--	__le32 flags;           /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--
--/*
-- * Describes the physical link runtime supported configs or params
-- *
-- * File block representation for physical link config :-
-- * +-----------------------------------+-----+
-- * | struct snd_soc_tplg_hdr           |  1  |
-- * +-----------------------------------+-----+
-- * | struct snd_soc_tplg_link_config   |  N  |
-- * +-----------------------------------+-----+
-- */
--struct snd_soc_tplg_link_config {
--	__le32 size;            /* in bytes of this structure */
--	__le32 id;              /* unique ID - used to match */
--	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */
--	char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* stream name - used to match */
--	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */
--	__le32 num_streams;     /* number of streams */
--	struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; /* hw configs */
--	__le32 num_hw_configs;         /* number of hw configs */
--	__le32 default_hw_config_id;   /* default hw config ID for init */
--	__le32 flag_mask;       /* bitmask of flags to configure */
--	__le32 flags;           /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--/*
-- * Describes SW/FW specific features of physical DAI.
-- * It can be used to configure backend DAIs for DPCM.
-- *
-- * File block representation for physical DAI :-
-- * +-----------------------------------+-----+
-- * | struct snd_soc_tplg_hdr           |  1  |
-- * +-----------------------------------+-----+
-- * | struct snd_soc_tplg_dai           |  N  |
-- * +-----------------------------------+-----+
-- */
--struct snd_soc_tplg_dai {
--	__le32 size;            /* in bytes of this structure */
--	char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */
--	__le32 dai_id;          /* unique ID - used to match */
--	__le32 playback;        /* supports playback mode */
--	__le32 capture;         /* supports capture mode */
--	struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */
--	__le32 flag_mask;       /* bitmask of flags to configure */
--	__le32 flags;           /* SND_SOC_TPLG_DAI_FLGBIT_* */
--	struct snd_soc_tplg_private priv;
--} __attribute__((packed));
--
--/*
-- * Old version of ABI structs, supported for backward compatibility.
-- */
--
--/* Manifest v4 */
--struct snd_soc_tplg_manifest_v4 {
--	__le32 size;		/* in bytes of this structure */
--	__le32 control_elems;	/* number of control elements */
--	__le32 widget_elems;	/* number of widget elements */
--	__le32 graph_elems;	/* number of graph elements */
--	__le32 pcm_elems;	/* number of PCM elements */
--	__le32 dai_link_elems;	/* number of DAI link elements */
--	struct snd_soc_tplg_private priv;
--} __packed;
--
--/* Stream Capabilities v4 */
--struct snd_soc_tplg_stream_caps_v4 {
--	__le32 size;		/* in bytes of this structure */
--	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	__le64 formats;	/* supported formats SNDRV_PCM_FMTBIT_* */
--	__le32 rates;		/* supported rates SNDRV_PCM_RATE_* */
--	__le32 rate_min;	/* min rate */
--	__le32 rate_max;	/* max rate */
--	__le32 channels_min;	/* min channels */
--	__le32 channels_max;	/* max channels */
--	__le32 periods_min;	/* min number of periods */
--	__le32 periods_max;	/* max number of periods */
--	__le32 period_size_min;	/* min period size bytes */
--	__le32 period_size_max;	/* max period size bytes */
--	__le32 buffer_size_min;	/* min buffer size bytes */
--	__le32 buffer_size_max;	/* max buffer size bytes */
--} __packed;
--
--/* PCM v4 */
--struct snd_soc_tplg_pcm_v4 {
--	__le32 size;		/* in bytes of this structure */
--	char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
--	__le32 pcm_id;		/* unique ID - used to match with DAI link */
--	__le32 dai_id;		/* unique ID - used to match */
--	__le32 playback;	/* supports playback mode */
--	__le32 capture;		/* supports capture mode */
--	__le32 compress;	/* 1 = compressed; 0 = PCM */
--	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */
--	__le32 num_streams;	/* number of streams */
--	struct snd_soc_tplg_stream_caps_v4 caps[2]; /* playback and capture for DAI */
--} __packed;
--
--/* Physical link config v4 */
--struct snd_soc_tplg_link_config_v4 {
--	__le32 size;            /* in bytes of this structure */
--	__le32 id;              /* unique ID - used to match */
--	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */
--	__le32 num_streams;     /* number of streams */
--} __packed;
--
--#endif
-+#include <alsa/sound/uapi/asoc.h>
-diff --git a/include/sound/asound.h b/include/sound/asound.h
-index df1153ce..3be4d850 100644
---- a/include/sound/asound.h
-+++ b/include/sound/asound.h
-@@ -1,1038 +1 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--/*
-- *  Advanced Linux Sound Architecture - ALSA - Driver
-- *  Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>,
-- *                             Abramo Bagnara <abramo@alsa-project.org>
-- *
-- *
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-- *
-- */
--
--#ifndef _UAPI__SOUND_ASOUND_H
--#define _UAPI__SOUND_ASOUND_H
--
--#if defined(__KERNEL__) || defined(__linux__)
--#include <linux/types.h>
--#else
--#include <sys/ioctl.h>
--#endif
--
--#ifndef __KERNEL__
--#include <stdlib.h>
--#include <time.h>
--#endif
--
--/*
-- *  protocol version
-- */
--
--#define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor))
--#define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff)
--#define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff)
--#define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff)
--#define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \
--	(SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \
--	 (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \
--	   SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion)))
--
--/****************************************************************************
-- *                                                                          *
-- *        Digital audio interface					    *
-- *                                                                          *
-- ****************************************************************************/
--
--struct snd_aes_iec958 {
--	unsigned char status[24];	/* AES/IEC958 channel status bits */
--	unsigned char subcode[147];	/* AES/IEC958 subcode bits */
--	unsigned char pad;		/* nothing */
--	unsigned char dig_subframe[4];	/* AES/IEC958 subframe bits */
--};
--
--/****************************************************************************
-- *                                                                          *
-- *        CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort		    *
-- *                                                                          *
-- ****************************************************************************/
--
--struct snd_cea_861_aud_if {
--	unsigned char db1_ct_cc; /* coding type and channel count */
--	unsigned char db2_sf_ss; /* sample frequency and size */
--	unsigned char db3; /* not used, all zeros */
--	unsigned char db4_ca; /* channel allocation code */
--	unsigned char db5_dminh_lsv; /* downmix inhibit & level-shit values */
--};
--
--/****************************************************************************
-- *                                                                          *
-- *      Section for driver hardware dependent interface - /dev/snd/hw?      *
-- *                                                                          *
-- ****************************************************************************/
--
--#define SNDRV_HWDEP_VERSION		SNDRV_PROTOCOL_VERSION(1, 0, 1)
--
--enum {
--	SNDRV_HWDEP_IFACE_OPL2 = 0,
--	SNDRV_HWDEP_IFACE_OPL3,
--	SNDRV_HWDEP_IFACE_OPL4,
--	SNDRV_HWDEP_IFACE_SB16CSP,	/* Creative Signal Processor */
--	SNDRV_HWDEP_IFACE_EMU10K1,	/* FX8010 processor in EMU10K1 chip */
--	SNDRV_HWDEP_IFACE_YSS225,	/* Yamaha FX processor */
--	SNDRV_HWDEP_IFACE_ICS2115,	/* Wavetable synth */
--	SNDRV_HWDEP_IFACE_SSCAPE,	/* Ensoniq SoundScape ISA card (MC68EC000) */
--	SNDRV_HWDEP_IFACE_VX,		/* Digigram VX cards */
--	SNDRV_HWDEP_IFACE_MIXART,	/* Digigram miXart cards */
--	SNDRV_HWDEP_IFACE_USX2Y,	/* Tascam US122, US224 & US428 usb */
--	SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */
--	SNDRV_HWDEP_IFACE_BLUETOOTH,	/* Bluetooth audio */
--	SNDRV_HWDEP_IFACE_USX2Y_PCM,	/* Tascam US122, US224 & US428 rawusb pcm */
--	SNDRV_HWDEP_IFACE_PCXHR,	/* Digigram PCXHR */
--	SNDRV_HWDEP_IFACE_SB_RC,	/* SB Extigy/Audigy2NX remote control */
--	SNDRV_HWDEP_IFACE_HDA,		/* HD-audio */
--	SNDRV_HWDEP_IFACE_USB_STREAM,	/* direct access to usb stream */
--	SNDRV_HWDEP_IFACE_FW_DICE,	/* TC DICE FireWire device */
--	SNDRV_HWDEP_IFACE_FW_FIREWORKS,	/* Echo Audio Fireworks based device */
--	SNDRV_HWDEP_IFACE_FW_BEBOB,	/* BridgeCo BeBoB based device */
--	SNDRV_HWDEP_IFACE_FW_OXFW,	/* Oxford OXFW970/971 based device */
--	SNDRV_HWDEP_IFACE_FW_DIGI00X,	/* Digidesign Digi 002/003 family */
--	SNDRV_HWDEP_IFACE_FW_TASCAM,	/* TASCAM FireWire series */
--	SNDRV_HWDEP_IFACE_LINE6,	/* Line6 USB processors */
--	SNDRV_HWDEP_IFACE_FW_MOTU,	/* MOTU FireWire series */
--	SNDRV_HWDEP_IFACE_FW_FIREFACE,	/* RME Fireface series */
--
--	/* Don't forget to change the following: */
--	SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_FIREFACE
--};
--
--struct snd_hwdep_info {
--	unsigned int device;		/* WR: device number */
--	int card;			/* R: card number */
--	unsigned char id[64];		/* ID (user selectable) */
--	unsigned char name[80];		/* hwdep name */
--	int iface;			/* hwdep interface */
--	unsigned char reserved[64];	/* reserved for future */
--};
--
--/* generic DSP loader */
--struct snd_hwdep_dsp_status {
--	unsigned int version;		/* R: driver-specific version */
--	unsigned char id[32];		/* R: driver-specific ID string */
--	unsigned int num_dsps;		/* R: number of DSP images to transfer */
--	unsigned int dsp_loaded;	/* R: bit flags indicating the loaded DSPs */
--	unsigned int chip_ready;	/* R: 1 = initialization finished */
--	unsigned char reserved[16];	/* reserved for future use */
--};
--
--struct snd_hwdep_dsp_image {
--	unsigned int index;		/* W: DSP index */
--	unsigned char name[64];		/* W: ID (e.g. file name) */
--	unsigned char __user *image;	/* W: binary image */
--	size_t length;			/* W: size of image in bytes */
--	unsigned long driver_data;	/* W: driver-specific data */
--};
--
--#define SNDRV_HWDEP_IOCTL_PVERSION	_IOR ('H', 0x00, int)
--#define SNDRV_HWDEP_IOCTL_INFO		_IOR ('H', 0x01, struct snd_hwdep_info)
--#define SNDRV_HWDEP_IOCTL_DSP_STATUS	_IOR('H', 0x02, struct snd_hwdep_dsp_status)
--#define SNDRV_HWDEP_IOCTL_DSP_LOAD	_IOW('H', 0x03, struct snd_hwdep_dsp_image)
--
--/*****************************************************************************
-- *                                                                           *
-- *             Digital Audio (PCM) interface - /dev/snd/pcm??                *
-- *                                                                           *
-- *****************************************************************************/
--
--#define SNDRV_PCM_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 14)
--
--typedef unsigned long snd_pcm_uframes_t;
--typedef signed long snd_pcm_sframes_t;
--
--enum {
--	SNDRV_PCM_CLASS_GENERIC = 0,	/* standard mono or stereo device */
--	SNDRV_PCM_CLASS_MULTI,		/* multichannel device */
--	SNDRV_PCM_CLASS_MODEM,		/* software modem class */
--	SNDRV_PCM_CLASS_DIGITIZER,	/* digitizer class */
--	/* Don't forget to change the following: */
--	SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER,
--};
--
--enum {
--	SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */
--	SNDRV_PCM_SUBCLASS_MULTI_MIX,	/* multichannel subdevices are mixed together */
--	/* Don't forget to change the following: */
--	SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX,
--};
--
--enum {
--	SNDRV_PCM_STREAM_PLAYBACK = 0,
--	SNDRV_PCM_STREAM_CAPTURE,
--	SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE,
--};
--
--typedef int __bitwise snd_pcm_access_t;
--#define	SNDRV_PCM_ACCESS_MMAP_INTERLEAVED	((__force snd_pcm_access_t) 0) /* interleaved mmap */
--#define	SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED	((__force snd_pcm_access_t) 1) /* noninterleaved mmap */
--#define	SNDRV_PCM_ACCESS_MMAP_COMPLEX		((__force snd_pcm_access_t) 2) /* complex mmap */
--#define	SNDRV_PCM_ACCESS_RW_INTERLEAVED		((__force snd_pcm_access_t) 3) /* readi/writei */
--#define	SNDRV_PCM_ACCESS_RW_NONINTERLEAVED	((__force snd_pcm_access_t) 4) /* readn/writen */
--#define	SNDRV_PCM_ACCESS_LAST		SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
--
--typedef int __bitwise snd_pcm_format_t;
--#define	SNDRV_PCM_FORMAT_S8	((__force snd_pcm_format_t) 0)
--#define	SNDRV_PCM_FORMAT_U8	((__force snd_pcm_format_t) 1)
--#define	SNDRV_PCM_FORMAT_S16_LE	((__force snd_pcm_format_t) 2)
--#define	SNDRV_PCM_FORMAT_S16_BE	((__force snd_pcm_format_t) 3)
--#define	SNDRV_PCM_FORMAT_U16_LE	((__force snd_pcm_format_t) 4)
--#define	SNDRV_PCM_FORMAT_U16_BE	((__force snd_pcm_format_t) 5)
--#define	SNDRV_PCM_FORMAT_S24_LE	((__force snd_pcm_format_t) 6) /* low three bytes */
--#define	SNDRV_PCM_FORMAT_S24_BE	((__force snd_pcm_format_t) 7) /* low three bytes */
--#define	SNDRV_PCM_FORMAT_U24_LE	((__force snd_pcm_format_t) 8) /* low three bytes */
--#define	SNDRV_PCM_FORMAT_U24_BE	((__force snd_pcm_format_t) 9) /* low three bytes */
--#define	SNDRV_PCM_FORMAT_S32_LE	((__force snd_pcm_format_t) 10)
--#define	SNDRV_PCM_FORMAT_S32_BE	((__force snd_pcm_format_t) 11)
--#define	SNDRV_PCM_FORMAT_U32_LE	((__force snd_pcm_format_t) 12)
--#define	SNDRV_PCM_FORMAT_U32_BE	((__force snd_pcm_format_t) 13)
--#define	SNDRV_PCM_FORMAT_FLOAT_LE	((__force snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
--#define	SNDRV_PCM_FORMAT_FLOAT_BE	((__force snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
--#define	SNDRV_PCM_FORMAT_FLOAT64_LE	((__force snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
--#define	SNDRV_PCM_FORMAT_FLOAT64_BE	((__force snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
--#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */
--#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */
--#define	SNDRV_PCM_FORMAT_MU_LAW		((__force snd_pcm_format_t) 20)
--#define	SNDRV_PCM_FORMAT_A_LAW		((__force snd_pcm_format_t) 21)
--#define	SNDRV_PCM_FORMAT_IMA_ADPCM	((__force snd_pcm_format_t) 22)
--#define	SNDRV_PCM_FORMAT_MPEG		((__force snd_pcm_format_t) 23)
--#define	SNDRV_PCM_FORMAT_GSM		((__force snd_pcm_format_t) 24)
--#define	SNDRV_PCM_FORMAT_S20_LE	((__force snd_pcm_format_t) 25) /* in four bytes, LSB justified */
--#define	SNDRV_PCM_FORMAT_S20_BE	((__force snd_pcm_format_t) 26) /* in four bytes, LSB justified */
--#define	SNDRV_PCM_FORMAT_U20_LE	((__force snd_pcm_format_t) 27) /* in four bytes, LSB justified */
--#define	SNDRV_PCM_FORMAT_U20_BE	((__force snd_pcm_format_t) 28) /* in four bytes, LSB justified */
--/* gap in the numbering for a future standard linear format */
--#define	SNDRV_PCM_FORMAT_SPECIAL	((__force snd_pcm_format_t) 31)
--#define	SNDRV_PCM_FORMAT_S24_3LE	((__force snd_pcm_format_t) 32)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_S24_3BE	((__force snd_pcm_format_t) 33)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_U24_3LE	((__force snd_pcm_format_t) 34)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_U24_3BE	((__force snd_pcm_format_t) 35)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_S20_3LE	((__force snd_pcm_format_t) 36)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_S20_3BE	((__force snd_pcm_format_t) 37)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_U20_3LE	((__force snd_pcm_format_t) 38)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_U20_3BE	((__force snd_pcm_format_t) 39)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_S18_3LE	((__force snd_pcm_format_t) 40)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_S18_3BE	((__force snd_pcm_format_t) 41)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_U18_3LE	((__force snd_pcm_format_t) 42)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_U18_3BE	((__force snd_pcm_format_t) 43)	/* in three bytes */
--#define	SNDRV_PCM_FORMAT_G723_24	((__force snd_pcm_format_t) 44) /* 8 samples in 3 bytes */
--#define	SNDRV_PCM_FORMAT_G723_24_1B	((__force snd_pcm_format_t) 45) /* 1 sample in 1 byte */
--#define	SNDRV_PCM_FORMAT_G723_40	((__force snd_pcm_format_t) 46) /* 8 Samples in 5 bytes */
--#define	SNDRV_PCM_FORMAT_G723_40_1B	((__force snd_pcm_format_t) 47) /* 1 sample in 1 byte */
--#define	SNDRV_PCM_FORMAT_DSD_U8		((__force snd_pcm_format_t) 48) /* DSD, 1-byte samples DSD (x8) */
--#define	SNDRV_PCM_FORMAT_DSD_U16_LE	((__force snd_pcm_format_t) 49) /* DSD, 2-byte samples DSD (x16), little endian */
--#define	SNDRV_PCM_FORMAT_DSD_U32_LE	((__force snd_pcm_format_t) 50) /* DSD, 4-byte samples DSD (x32), little endian */
--#define	SNDRV_PCM_FORMAT_DSD_U16_BE	((__force snd_pcm_format_t) 51) /* DSD, 2-byte samples DSD (x16), big endian */
--#define	SNDRV_PCM_FORMAT_DSD_U32_BE	((__force snd_pcm_format_t) 52) /* DSD, 4-byte samples DSD (x32), big endian */
--#define	SNDRV_PCM_FORMAT_LAST		SNDRV_PCM_FORMAT_DSD_U32_BE
--#define	SNDRV_PCM_FORMAT_FIRST		SNDRV_PCM_FORMAT_S8
--
--#ifdef SNDRV_LITTLE_ENDIAN
--#define	SNDRV_PCM_FORMAT_S16		SNDRV_PCM_FORMAT_S16_LE
--#define	SNDRV_PCM_FORMAT_U16		SNDRV_PCM_FORMAT_U16_LE
--#define	SNDRV_PCM_FORMAT_S24		SNDRV_PCM_FORMAT_S24_LE
--#define	SNDRV_PCM_FORMAT_U24		SNDRV_PCM_FORMAT_U24_LE
--#define	SNDRV_PCM_FORMAT_S32		SNDRV_PCM_FORMAT_S32_LE
--#define	SNDRV_PCM_FORMAT_U32		SNDRV_PCM_FORMAT_U32_LE
--#define	SNDRV_PCM_FORMAT_FLOAT		SNDRV_PCM_FORMAT_FLOAT_LE
--#define	SNDRV_PCM_FORMAT_FLOAT64	SNDRV_PCM_FORMAT_FLOAT64_LE
--#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE
--#define	SNDRV_PCM_FORMAT_S20		SNDRV_PCM_FORMAT_S20_LE
--#define	SNDRV_PCM_FORMAT_U20		SNDRV_PCM_FORMAT_U20_LE
--#endif
--#ifdef SNDRV_BIG_ENDIAN
--#define	SNDRV_PCM_FORMAT_S16		SNDRV_PCM_FORMAT_S16_BE
--#define	SNDRV_PCM_FORMAT_U16		SNDRV_PCM_FORMAT_U16_BE
--#define	SNDRV_PCM_FORMAT_S24		SNDRV_PCM_FORMAT_S24_BE
--#define	SNDRV_PCM_FORMAT_U24		SNDRV_PCM_FORMAT_U24_BE
--#define	SNDRV_PCM_FORMAT_S32		SNDRV_PCM_FORMAT_S32_BE
--#define	SNDRV_PCM_FORMAT_U32		SNDRV_PCM_FORMAT_U32_BE
--#define	SNDRV_PCM_FORMAT_FLOAT		SNDRV_PCM_FORMAT_FLOAT_BE
--#define	SNDRV_PCM_FORMAT_FLOAT64	SNDRV_PCM_FORMAT_FLOAT64_BE
--#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE
--#define	SNDRV_PCM_FORMAT_S20		SNDRV_PCM_FORMAT_S20_BE
--#define	SNDRV_PCM_FORMAT_U20		SNDRV_PCM_FORMAT_U20_BE
--#endif
--
--typedef int __bitwise snd_pcm_subformat_t;
--#define	SNDRV_PCM_SUBFORMAT_STD		((__force snd_pcm_subformat_t) 0)
--#define	SNDRV_PCM_SUBFORMAT_LAST	SNDRV_PCM_SUBFORMAT_STD
--
--#define SNDRV_PCM_INFO_MMAP		0x00000001	/* hardware supports mmap */
--#define SNDRV_PCM_INFO_MMAP_VALID	0x00000002	/* period data are valid during transfer */
--#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_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) */
--#define SNDRV_PCM_INFO_BLOCK_TRANSFER	0x00010000	/* hardware transfer block of samples */
--#define SNDRV_PCM_INFO_OVERRANGE	0x00020000	/* hardware supports ADC (capture) overrange detection */
--#define SNDRV_PCM_INFO_RESUME		0x00040000	/* hardware supports stream resume after suspend */
--#define SNDRV_PCM_INFO_PAUSE		0x00080000	/* pause ioctl is supported */
--#define SNDRV_PCM_INFO_HALF_DUPLEX	0x00100000	/* only half duplex */
--#define SNDRV_PCM_INFO_JOINT_DUPLEX	0x00200000	/* playback and capture stream are somewhat correlated */
--#define SNDRV_PCM_INFO_SYNC_START	0x00400000	/* pcm support some kind of sync go */
--#define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP	0x00800000	/* period wakeup can be disabled */
--#define SNDRV_PCM_INFO_HAS_WALL_CLOCK   0x01000000      /* (Deprecated)has audio wall clock for audio/system time sync */
--#define SNDRV_PCM_INFO_HAS_LINK_ATIME              0x01000000  /* report hardware link audio time, reset on startup */
--#define SNDRV_PCM_INFO_HAS_LINK_ABSOLUTE_ATIME     0x02000000  /* report absolute hardware link audio time, not reset on startup */
--#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME    0x04000000  /* report estimated link audio time */
--#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000  /* report synchronized audio/system time */
--
--#define SNDRV_PCM_INFO_DRAIN_TRIGGER	0x40000000		/* internal kernel flag - trigger in drain */
--#define SNDRV_PCM_INFO_FIFO_IN_FRAMES	0x80000000	/* internal kernel flag - FIFO size is in frames */
--
--
--
--typedef int __bitwise snd_pcm_state_t;
--#define	SNDRV_PCM_STATE_OPEN		((__force snd_pcm_state_t) 0) /* stream is open */
--#define	SNDRV_PCM_STATE_SETUP		((__force snd_pcm_state_t) 1) /* stream has a setup */
--#define	SNDRV_PCM_STATE_PREPARED	((__force snd_pcm_state_t) 2) /* stream is ready to start */
--#define	SNDRV_PCM_STATE_RUNNING		((__force snd_pcm_state_t) 3) /* stream is running */
--#define	SNDRV_PCM_STATE_XRUN		((__force snd_pcm_state_t) 4) /* stream reached an xrun */
--#define	SNDRV_PCM_STATE_DRAINING	((__force snd_pcm_state_t) 5) /* stream is draining */
--#define	SNDRV_PCM_STATE_PAUSED		((__force snd_pcm_state_t) 6) /* stream is paused */
--#define	SNDRV_PCM_STATE_SUSPENDED	((__force snd_pcm_state_t) 7) /* hardware is suspended */
--#define	SNDRV_PCM_STATE_DISCONNECTED	((__force snd_pcm_state_t) 8) /* hardware is disconnected */
--#define	SNDRV_PCM_STATE_LAST		SNDRV_PCM_STATE_DISCONNECTED
--
--enum {
--	SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000,
--	SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000,
--	SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000,
--};
--
--union snd_pcm_sync_id {
--	unsigned char id[16];
--	unsigned short id16[8];
--	unsigned int id32[4];
--};
--
--struct snd_pcm_info {
--	unsigned int device;		/* RO/WR (control): device number */
--	unsigned int subdevice;		/* RO/WR (control): subdevice number */
--	int stream;			/* RO/WR (control): stream direction */
--	int card;			/* R: card number */
--	unsigned char id[64];		/* ID (user selectable) */
--	unsigned char name[80];		/* name of this device */
--	unsigned char subname[32];	/* subdevice name */
--	int dev_class;			/* SNDRV_PCM_CLASS_* */
--	int dev_subclass;		/* SNDRV_PCM_SUBCLASS_* */
--	unsigned int subdevices_count;
--	unsigned int subdevices_avail;
--	union snd_pcm_sync_id sync;	/* hardware synchronization ID */
--	unsigned char reserved[64];	/* reserved for future... */
--};
--
--typedef int snd_pcm_hw_param_t;
--#define	SNDRV_PCM_HW_PARAM_ACCESS	0	/* Access type */
--#define	SNDRV_PCM_HW_PARAM_FORMAT	1	/* Format */
--#define	SNDRV_PCM_HW_PARAM_SUBFORMAT	2	/* Subformat */
--#define	SNDRV_PCM_HW_PARAM_FIRST_MASK	SNDRV_PCM_HW_PARAM_ACCESS
--#define	SNDRV_PCM_HW_PARAM_LAST_MASK	SNDRV_PCM_HW_PARAM_SUBFORMAT
--
--#define	SNDRV_PCM_HW_PARAM_SAMPLE_BITS	8	/* Bits per sample */
--#define	SNDRV_PCM_HW_PARAM_FRAME_BITS	9	/* Bits per frame */
--#define	SNDRV_PCM_HW_PARAM_CHANNELS	10	/* Channels */
--#define	SNDRV_PCM_HW_PARAM_RATE		11	/* Approx rate */
--#define	SNDRV_PCM_HW_PARAM_PERIOD_TIME	12	/* Approx distance between
--						 * interrupts in us
--						 */
--#define	SNDRV_PCM_HW_PARAM_PERIOD_SIZE	13	/* Approx frames between
--						 * interrupts
--						 */
--#define	SNDRV_PCM_HW_PARAM_PERIOD_BYTES	14	/* Approx bytes between
--						 * interrupts
--						 */
--#define	SNDRV_PCM_HW_PARAM_PERIODS	15	/* Approx interrupts per
--						 * buffer
--						 */
--#define	SNDRV_PCM_HW_PARAM_BUFFER_TIME	16	/* Approx duration of buffer
--						 * in us
--						 */
--#define	SNDRV_PCM_HW_PARAM_BUFFER_SIZE	17	/* Size of buffer in frames */
--#define	SNDRV_PCM_HW_PARAM_BUFFER_BYTES	18	/* Size of buffer in bytes */
--#define	SNDRV_PCM_HW_PARAM_TICK_TIME	19	/* Approx tick duration in us */
--#define	SNDRV_PCM_HW_PARAM_FIRST_INTERVAL	SNDRV_PCM_HW_PARAM_SAMPLE_BITS
--#define	SNDRV_PCM_HW_PARAM_LAST_INTERVAL	SNDRV_PCM_HW_PARAM_TICK_TIME
--
--#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 */
--
--struct snd_interval {
--	unsigned int min, max;
--	unsigned int openmin:1,
--		     openmax:1,
--		     integer:1,
--		     empty:1;
--};
--
--#define SNDRV_MASK_MAX	256
--
--struct snd_mask {
--	__u32 bits[(SNDRV_MASK_MAX+31)/32];
--};
--
--struct snd_pcm_hw_params {
--	unsigned int flags;
--	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
--			       SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
--	struct snd_mask mres[5];	/* reserved masks */
--	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
--				        SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
--	struct snd_interval ires[9];	/* reserved intervals */
--	unsigned int rmask;		/* W: requested masks */
--	unsigned int cmask;		/* R: changed masks */
--	unsigned int info;		/* R: Info flags for returned setup */
--	unsigned int msbits;		/* R: used most significant bits */
--	unsigned int rate_num;		/* R: rate numerator */
--	unsigned int rate_den;		/* R: rate denominator */
--	snd_pcm_uframes_t fifo_size;	/* R: chip FIFO size in frames */
--	unsigned char reserved[64];	/* reserved for future */
--};
--
--enum {
--	SNDRV_PCM_TSTAMP_NONE = 0,
--	SNDRV_PCM_TSTAMP_ENABLE,
--	SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE,
--};
--
--struct snd_pcm_sw_params {
--	int tstamp_mode;			/* timestamp mode */
--	unsigned int period_step;
--	unsigned int sleep_min;			/* min ticks to sleep */
--	snd_pcm_uframes_t avail_min;		/* min avail frames for wakeup */
--	snd_pcm_uframes_t xfer_align;		/* obsolete: xfer size need to be a multiple */
--	snd_pcm_uframes_t start_threshold;	/* min hw_avail frames for automatic start */
--	snd_pcm_uframes_t stop_threshold;	/* min avail frames for automatic stop */
--	snd_pcm_uframes_t silence_threshold;	/* min distance from noise for silence filling */
--	snd_pcm_uframes_t silence_size;		/* silence block size */
--	snd_pcm_uframes_t boundary;		/* pointers wrap point */
--	unsigned int proto;			/* protocol version */
--	unsigned int tstamp_type;		/* timestamp type (req. proto >= 2.0.12) */
--	unsigned char reserved[56];		/* reserved for future */
--};
--
--struct snd_pcm_channel_info {
--	unsigned int channel;
--	__kernel_off_t offset;		/* mmap offset */
--	unsigned int first;		/* offset to first sample in bits */
--	unsigned int step;		/* samples distance in bits */
--};
--
--enum {
--	/*
--	 *  first definition for backwards compatibility only,
--	 *  maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else
--	 */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0,
--
--	/* timestamp definitions */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1,           /* DMA time, reported as per hw_ptr */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2,	           /* link time reported by sample or wallclock counter, reset on startup */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3,	   /* link time reported by sample or wallclock counter, not reset on startup */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4,    /* link time estimated indirectly */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, /* link time synchronized with system time */
--	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED
--};
--
--struct snd_pcm_status {
--	snd_pcm_state_t state;		/* stream state */
--	struct timespec trigger_tstamp;	/* time when stream was started/stopped/paused */
--	struct timespec tstamp;		/* reference timestamp */
--	snd_pcm_uframes_t appl_ptr;	/* appl ptr */
--	snd_pcm_uframes_t hw_ptr;	/* hw ptr */
--	snd_pcm_sframes_t delay;	/* current delay in frames */
--	snd_pcm_uframes_t avail;	/* number of frames available */
--	snd_pcm_uframes_t avail_max;	/* max frames available on hw since last status */
--	snd_pcm_uframes_t overrange;	/* count of ADC (capture) overrange detections from last status */
--	snd_pcm_state_t suspended_state; /* suspended stream state */
--	__u32 audio_tstamp_data;	 /* needed for 64-bit alignment, used for configs/report to/from userspace */
--	struct timespec audio_tstamp;	/* sample counter, wall clock, PHC or on-demand sync'ed */
--	struct timespec driver_tstamp;	/* useful in case reference system tstamp is reported with delay */
--	__u32 audio_tstamp_accuracy;	/* in ns units, only valid if indicated in audio_tstamp_data */
--	unsigned char reserved[52-2*sizeof(struct timespec)]; /* must be filled with zero */
--};
--
--struct snd_pcm_mmap_status {
--	snd_pcm_state_t state;		/* RO: state - SNDRV_PCM_STATE_XXXX */
--	int pad1;			/* Needed for 64 bit alignment */
--	snd_pcm_uframes_t hw_ptr;	/* RO: hw ptr (0...boundary-1) */
--	struct timespec tstamp;		/* Timestamp */
--	snd_pcm_state_t suspended_state; /* RO: suspended stream state */
--	struct timespec audio_tstamp;	/* from sample counter or wall clock */
--};
--
--struct snd_pcm_mmap_control {
--	snd_pcm_uframes_t appl_ptr;	/* RW: appl ptr (0...boundary-1) */
--	snd_pcm_uframes_t avail_min;	/* RW: min available frames for wakeup */
--};
--
--#define SNDRV_PCM_SYNC_PTR_HWSYNC	(1<<0)	/* execute hwsync */
--#define SNDRV_PCM_SYNC_PTR_APPL		(1<<1)	/* get appl_ptr from driver (r/w op) */
--#define SNDRV_PCM_SYNC_PTR_AVAIL_MIN	(1<<2)	/* get avail_min from driver */
--
--struct snd_pcm_sync_ptr {
--	unsigned int flags;
--	union {
--		struct snd_pcm_mmap_status status;
--		unsigned char reserved[64];
--	} s;
--	union {
--		struct snd_pcm_mmap_control control;
--		unsigned char reserved[64];
--	} c;
--};
--
--struct snd_xferi {
--	snd_pcm_sframes_t result;
--	void __user *buf;
--	snd_pcm_uframes_t frames;
--};
--
--struct snd_xfern {
--	snd_pcm_sframes_t result;
--	void __user * __user *bufs;
--	snd_pcm_uframes_t frames;
--};
--
--enum {
--	SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0,	/* gettimeofday equivalent */
--	SNDRV_PCM_TSTAMP_TYPE_MONOTONIC,	/* posix_clock_monotonic equivalent */
--	SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW,    /* monotonic_raw (no NTP) */
--	SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW,
--};
--
--/* channel positions */
--enum {
--	SNDRV_CHMAP_UNKNOWN = 0,
--	SNDRV_CHMAP_NA,		/* N/A, silent */
--	SNDRV_CHMAP_MONO,	/* mono stream */
--	/* this follows the alsa-lib mixer channel value + 3 */
--	SNDRV_CHMAP_FL,		/* front left */
--	SNDRV_CHMAP_FR,		/* front right */
--	SNDRV_CHMAP_RL,		/* rear left */
--	SNDRV_CHMAP_RR,		/* rear right */
--	SNDRV_CHMAP_FC,		/* front center */
--	SNDRV_CHMAP_LFE,	/* LFE */
--	SNDRV_CHMAP_SL,		/* side left */
--	SNDRV_CHMAP_SR,		/* side right */
--	SNDRV_CHMAP_RC,		/* rear center */
--	/* new definitions */
--	SNDRV_CHMAP_FLC,	/* front left center */
--	SNDRV_CHMAP_FRC,	/* front right center */
--	SNDRV_CHMAP_RLC,	/* rear left center */
--	SNDRV_CHMAP_RRC,	/* rear right center */
--	SNDRV_CHMAP_FLW,	/* front left wide */
--	SNDRV_CHMAP_FRW,	/* front right wide */
--	SNDRV_CHMAP_FLH,	/* front left high */
--	SNDRV_CHMAP_FCH,	/* front center high */
--	SNDRV_CHMAP_FRH,	/* front right high */
--	SNDRV_CHMAP_TC,		/* top center */
--	SNDRV_CHMAP_TFL,	/* top front left */
--	SNDRV_CHMAP_TFR,	/* top front right */
--	SNDRV_CHMAP_TFC,	/* top front center */
--	SNDRV_CHMAP_TRL,	/* top rear left */
--	SNDRV_CHMAP_TRR,	/* top rear right */
--	SNDRV_CHMAP_TRC,	/* top rear center */
--	/* new definitions for UAC2 */
--	SNDRV_CHMAP_TFLC,	/* top front left center */
--	SNDRV_CHMAP_TFRC,	/* top front right center */
--	SNDRV_CHMAP_TSL,	/* top side left */
--	SNDRV_CHMAP_TSR,	/* top side right */
--	SNDRV_CHMAP_LLFE,	/* left LFE */
--	SNDRV_CHMAP_RLFE,	/* right LFE */
--	SNDRV_CHMAP_BC,		/* bottom center */
--	SNDRV_CHMAP_BLC,	/* bottom left center */
--	SNDRV_CHMAP_BRC,	/* bottom right center */
--	SNDRV_CHMAP_LAST = SNDRV_CHMAP_BRC,
--};
--
--#define SNDRV_CHMAP_POSITION_MASK	0xffff
--#define SNDRV_CHMAP_PHASE_INVERSE	(0x01 << 16)
--#define SNDRV_CHMAP_DRIVER_SPEC		(0x02 << 16)
--
--#define SNDRV_PCM_IOCTL_PVERSION	_IOR('A', 0x00, int)
--#define SNDRV_PCM_IOCTL_INFO		_IOR('A', 0x01, struct snd_pcm_info)
--#define SNDRV_PCM_IOCTL_TSTAMP		_IOW('A', 0x02, int)
--#define SNDRV_PCM_IOCTL_TTSTAMP		_IOW('A', 0x03, int)
--#define SNDRV_PCM_IOCTL_USER_PVERSION	_IOW('A', 0x04, int)
--#define SNDRV_PCM_IOCTL_HW_REFINE	_IOWR('A', 0x10, struct snd_pcm_hw_params)
--#define SNDRV_PCM_IOCTL_HW_PARAMS	_IOWR('A', 0x11, struct snd_pcm_hw_params)
--#define SNDRV_PCM_IOCTL_HW_FREE		_IO('A', 0x12)
--#define SNDRV_PCM_IOCTL_SW_PARAMS	_IOWR('A', 0x13, struct snd_pcm_sw_params)
--#define SNDRV_PCM_IOCTL_STATUS		_IOR('A', 0x20, struct snd_pcm_status)
--#define SNDRV_PCM_IOCTL_DELAY		_IOR('A', 0x21, snd_pcm_sframes_t)
--#define SNDRV_PCM_IOCTL_HWSYNC		_IO('A', 0x22)
--#define SNDRV_PCM_IOCTL_SYNC_PTR	_IOWR('A', 0x23, struct snd_pcm_sync_ptr)
--#define SNDRV_PCM_IOCTL_STATUS_EXT	_IOWR('A', 0x24, struct snd_pcm_status)
--#define SNDRV_PCM_IOCTL_CHANNEL_INFO	_IOR('A', 0x32, struct snd_pcm_channel_info)
--#define SNDRV_PCM_IOCTL_PREPARE		_IO('A', 0x40)
--#define SNDRV_PCM_IOCTL_RESET		_IO('A', 0x41)
--#define SNDRV_PCM_IOCTL_START		_IO('A', 0x42)
--#define SNDRV_PCM_IOCTL_DROP		_IO('A', 0x43)
--#define SNDRV_PCM_IOCTL_DRAIN		_IO('A', 0x44)
--#define SNDRV_PCM_IOCTL_PAUSE		_IOW('A', 0x45, int)
--#define SNDRV_PCM_IOCTL_REWIND		_IOW('A', 0x46, snd_pcm_uframes_t)
--#define SNDRV_PCM_IOCTL_RESUME		_IO('A', 0x47)
--#define SNDRV_PCM_IOCTL_XRUN		_IO('A', 0x48)
--#define SNDRV_PCM_IOCTL_FORWARD		_IOW('A', 0x49, snd_pcm_uframes_t)
--#define SNDRV_PCM_IOCTL_WRITEI_FRAMES	_IOW('A', 0x50, struct snd_xferi)
--#define SNDRV_PCM_IOCTL_READI_FRAMES	_IOR('A', 0x51, struct snd_xferi)
--#define SNDRV_PCM_IOCTL_WRITEN_FRAMES	_IOW('A', 0x52, struct snd_xfern)
--#define SNDRV_PCM_IOCTL_READN_FRAMES	_IOR('A', 0x53, struct snd_xfern)
--#define SNDRV_PCM_IOCTL_LINK		_IOW('A', 0x60, int)
--#define SNDRV_PCM_IOCTL_UNLINK		_IO('A', 0x61)
--
--/*****************************************************************************
-- *                                                                           *
-- *                            MIDI v1.0 interface                            *
-- *                                                                           *
-- *****************************************************************************/
--
--/*
-- *  Raw MIDI section - /dev/snd/midi??
-- */
--
--#define SNDRV_RAWMIDI_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 0)
--
--enum {
--	SNDRV_RAWMIDI_STREAM_OUTPUT = 0,
--	SNDRV_RAWMIDI_STREAM_INPUT,
--	SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT,
--};
--
--#define SNDRV_RAWMIDI_INFO_OUTPUT		0x00000001
--#define SNDRV_RAWMIDI_INFO_INPUT		0x00000002
--#define SNDRV_RAWMIDI_INFO_DUPLEX		0x00000004
--
--struct snd_rawmidi_info {
--	unsigned int device;		/* RO/WR (control): device number */
--	unsigned int subdevice;		/* RO/WR (control): subdevice number */
--	int stream;			/* WR: stream */
--	int card;			/* R: card number */
--	unsigned int flags;		/* SNDRV_RAWMIDI_INFO_XXXX */
--	unsigned char id[64];		/* ID (user selectable) */
--	unsigned char name[80];		/* name of device */
--	unsigned char subname[32];	/* name of active or selected subdevice */
--	unsigned int subdevices_count;
--	unsigned int subdevices_avail;
--	unsigned char reserved[64];	/* reserved for future use */
--};
--
--struct snd_rawmidi_params {
--	int stream;
--	size_t buffer_size;		/* queue size in bytes */
--	size_t avail_min;		/* minimum avail bytes for wakeup */
--	unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */
--	unsigned char reserved[16];	/* reserved for future use */
--};
--
--struct snd_rawmidi_status {
--	int stream;
--	struct timespec tstamp;		/* Timestamp */
--	size_t avail;			/* available bytes */
--	size_t xruns;			/* count of overruns since last status (in bytes) */
--	unsigned char reserved[16];	/* reserved for future use */
--};
--
--#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_PARAMS	_IOWR('W', 0x10, struct snd_rawmidi_params)
--#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)
--
--/*
-- *  Timer section - /dev/snd/timer
-- */
--
--#define SNDRV_TIMER_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 6)
--
--enum {
--	SNDRV_TIMER_CLASS_NONE = -1,
--	SNDRV_TIMER_CLASS_SLAVE = 0,
--	SNDRV_TIMER_CLASS_GLOBAL,
--	SNDRV_TIMER_CLASS_CARD,
--	SNDRV_TIMER_CLASS_PCM,
--	SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM,
--};
--
--/* slave timer classes */
--enum {
--	SNDRV_TIMER_SCLASS_NONE = 0,
--	SNDRV_TIMER_SCLASS_APPLICATION,
--	SNDRV_TIMER_SCLASS_SEQUENCER,		/* alias */
--	SNDRV_TIMER_SCLASS_OSS_SEQUENCER,	/* alias */
--	SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER,
--};
--
--/* global timers (device member) */
--#define SNDRV_TIMER_GLOBAL_SYSTEM	0
--#define SNDRV_TIMER_GLOBAL_RTC		1	/* unused */
--#define SNDRV_TIMER_GLOBAL_HPET		2
--#define SNDRV_TIMER_GLOBAL_HRTIMER	3
--
--/* info flags */
--#define SNDRV_TIMER_FLG_SLAVE		(1<<0)	/* cannot be controlled */
--
--struct snd_timer_id {
--	int dev_class;
--	int dev_sclass;
--	int card;
--	int device;
--	int subdevice;
--};
--
--struct snd_timer_ginfo {
--	struct snd_timer_id tid;	/* requested timer ID */
--	unsigned int flags;		/* timer flags - SNDRV_TIMER_FLG_* */
--	int card;			/* card number */
--	unsigned char id[64];		/* timer identification */
--	unsigned char name[80];		/* timer name */
--	unsigned long reserved0;	/* reserved for future use */
--	unsigned long resolution;	/* average period resolution in ns */
--	unsigned long resolution_min;	/* minimal period resolution in ns */
--	unsigned long resolution_max;	/* maximal period resolution in ns */
--	unsigned int clients;		/* active timer clients */
--	unsigned char reserved[32];
--};
--
--struct snd_timer_gparams {
--	struct snd_timer_id tid;	/* requested timer ID */
--	unsigned long period_num;	/* requested precise period duration (in seconds) - numerator */
--	unsigned long period_den;	/* requested precise period duration (in seconds) - denominator */
--	unsigned char reserved[32];
--};
--
--struct snd_timer_gstatus {
--	struct snd_timer_id tid;	/* requested timer ID */
--	unsigned long resolution;	/* current period resolution in ns */
--	unsigned long resolution_num;	/* precise current period resolution (in seconds) - numerator */
--	unsigned long resolution_den;	/* precise current period resolution (in seconds) - denominator */
--	unsigned char reserved[32];
--};
--
--struct snd_timer_select {
--	struct snd_timer_id id;	/* bind to timer ID */
--	unsigned char reserved[32];	/* reserved */
--};
--
--struct snd_timer_info {
--	unsigned int flags;		/* timer flags - SNDRV_TIMER_FLG_* */
--	int card;			/* card number */
--	unsigned char id[64];		/* timer identificator */
--	unsigned char name[80];		/* timer name */
--	unsigned long reserved0;	/* reserved for future use */
--	unsigned long resolution;	/* average period resolution in ns */
--	unsigned char reserved[64];	/* reserved */
--};
--
--#define SNDRV_TIMER_PSFLG_AUTO		(1<<0)	/* auto start, otherwise one-shot */
--#define SNDRV_TIMER_PSFLG_EXCLUSIVE	(1<<1)	/* exclusive use, precise start/stop/pause/continue */
--#define SNDRV_TIMER_PSFLG_EARLY_EVENT	(1<<2)	/* write early event to the poll queue */
--
--struct snd_timer_params {
--	unsigned int flags;		/* flags - SNDRV_TIMER_PSFLG_* */
--	unsigned int ticks;		/* requested resolution in ticks */
--	unsigned int queue_size;	/* total size of queue (32-1024) */
--	unsigned int reserved0;		/* reserved, was: failure locations */
--	unsigned int filter;		/* event filter (bitmask of SNDRV_TIMER_EVENT_*) */
--	unsigned char reserved[60];	/* reserved */
--};
--
--struct snd_timer_status {
--	struct timespec tstamp;		/* Timestamp - last update */
--	unsigned int resolution;	/* current period resolution in ns */
--	unsigned int lost;		/* counter of master tick lost */
--	unsigned int overrun;		/* count of read queue overruns */
--	unsigned int queue;		/* used queue size */
--	unsigned char reserved[64];	/* reserved */
--};
--
--#define SNDRV_TIMER_IOCTL_PVERSION	_IOR('T', 0x00, int)
--#define SNDRV_TIMER_IOCTL_NEXT_DEVICE	_IOWR('T', 0x01, struct snd_timer_id)
--#define SNDRV_TIMER_IOCTL_TREAD		_IOW('T', 0x02, int)
--#define SNDRV_TIMER_IOCTL_GINFO		_IOWR('T', 0x03, struct snd_timer_ginfo)
--#define SNDRV_TIMER_IOCTL_GPARAMS	_IOW('T', 0x04, struct snd_timer_gparams)
--#define SNDRV_TIMER_IOCTL_GSTATUS	_IOWR('T', 0x05, struct snd_timer_gstatus)
--#define SNDRV_TIMER_IOCTL_SELECT	_IOW('T', 0x10, struct snd_timer_select)
--#define SNDRV_TIMER_IOCTL_INFO		_IOR('T', 0x11, struct snd_timer_info)
--#define SNDRV_TIMER_IOCTL_PARAMS	_IOW('T', 0x12, struct snd_timer_params)
--#define SNDRV_TIMER_IOCTL_STATUS	_IOR('T', 0x14, struct snd_timer_status)
--/* The following four ioctls are changed since 1.0.9 due to confliction */
--#define SNDRV_TIMER_IOCTL_START		_IO('T', 0xa0)
--#define SNDRV_TIMER_IOCTL_STOP		_IO('T', 0xa1)
--#define SNDRV_TIMER_IOCTL_CONTINUE	_IO('T', 0xa2)
--#define SNDRV_TIMER_IOCTL_PAUSE		_IO('T', 0xa3)
--
--struct snd_timer_read {
--	unsigned int resolution;
--	unsigned int ticks;
--};
--
--enum {
--	SNDRV_TIMER_EVENT_RESOLUTION = 0,	/* val = resolution in ns */
--	SNDRV_TIMER_EVENT_TICK,			/* val = ticks */
--	SNDRV_TIMER_EVENT_START,		/* val = resolution in ns */
--	SNDRV_TIMER_EVENT_STOP,			/* val = 0 */
--	SNDRV_TIMER_EVENT_CONTINUE,		/* val = resolution in ns */
--	SNDRV_TIMER_EVENT_PAUSE,		/* val = 0 */
--	SNDRV_TIMER_EVENT_EARLY,		/* val = 0, early event */
--	SNDRV_TIMER_EVENT_SUSPEND,		/* val = 0 */
--	SNDRV_TIMER_EVENT_RESUME,		/* val = resolution in ns */
--	/* master timer events for slave timer instances */
--	SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10,
--	SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10,
--	SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10,
--	SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10,
--	SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10,
--	SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10,
--};
--
--struct snd_timer_tread {
--	int event;
--	struct timespec tstamp;
--	unsigned int val;
--};
--
--/****************************************************************************
-- *                                                                          *
-- *        Section for driver control interface - /dev/snd/control?          *
-- *                                                                          *
-- ****************************************************************************/
--
--#define SNDRV_CTL_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 7)
--
--struct snd_ctl_card_info {
--	int card;			/* card number */
--	int pad;			/* reserved for future (was type) */
--	unsigned char id[16];		/* ID of card (user selectable) */
--	unsigned char driver[16];	/* Driver name */
--	unsigned char name[32];		/* Short name of soundcard */
--	unsigned char longname[80];	/* name + info text about soundcard */
--	unsigned char reserved_[16];	/* reserved for future (was ID of mixer) */
--	unsigned char mixername[80];	/* visual mixer identification */
--	unsigned char components[128];	/* card components / fine identification, delimited with one space (AC97 etc..) */
--};
--
--typedef int __bitwise snd_ctl_elem_type_t;
--#define	SNDRV_CTL_ELEM_TYPE_NONE	((__force snd_ctl_elem_type_t) 0) /* invalid */
--#define	SNDRV_CTL_ELEM_TYPE_BOOLEAN	((__force snd_ctl_elem_type_t) 1) /* boolean type */
--#define	SNDRV_CTL_ELEM_TYPE_INTEGER	((__force snd_ctl_elem_type_t) 2) /* integer type */
--#define	SNDRV_CTL_ELEM_TYPE_ENUMERATED	((__force snd_ctl_elem_type_t) 3) /* enumerated type */
--#define	SNDRV_CTL_ELEM_TYPE_BYTES	((__force snd_ctl_elem_type_t) 4) /* byte array */
--#define	SNDRV_CTL_ELEM_TYPE_IEC958	((__force snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */
--#define	SNDRV_CTL_ELEM_TYPE_INTEGER64	((__force snd_ctl_elem_type_t) 6) /* 64-bit integer type */
--#define	SNDRV_CTL_ELEM_TYPE_LAST	SNDRV_CTL_ELEM_TYPE_INTEGER64
--
--typedef int __bitwise snd_ctl_elem_iface_t;
--#define	SNDRV_CTL_ELEM_IFACE_CARD	((__force snd_ctl_elem_iface_t) 0) /* global control */
--#define	SNDRV_CTL_ELEM_IFACE_HWDEP	((__force snd_ctl_elem_iface_t) 1) /* hardware dependent device */
--#define	SNDRV_CTL_ELEM_IFACE_MIXER	((__force snd_ctl_elem_iface_t) 2) /* virtual mixer device */
--#define	SNDRV_CTL_ELEM_IFACE_PCM	((__force snd_ctl_elem_iface_t) 3) /* PCM device */
--#define	SNDRV_CTL_ELEM_IFACE_RAWMIDI	((__force snd_ctl_elem_iface_t) 4) /* RawMidi device */
--#define	SNDRV_CTL_ELEM_IFACE_TIMER	((__force snd_ctl_elem_iface_t) 5) /* timer device */
--#define	SNDRV_CTL_ELEM_IFACE_SEQUENCER	((__force snd_ctl_elem_iface_t) 6) /* sequencer client */
--#define	SNDRV_CTL_ELEM_IFACE_LAST	SNDRV_CTL_ELEM_IFACE_SEQUENCER
--
--#define SNDRV_CTL_ELEM_ACCESS_READ		(1<<0)
--#define SNDRV_CTL_ELEM_ACCESS_WRITE		(1<<1)
--#define SNDRV_CTL_ELEM_ACCESS_READWRITE		(SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE)
--#define SNDRV_CTL_ELEM_ACCESS_VOLATILE		(1<<2)	/* control value may be changed without a notification */
--#define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP		(1<<3)	/* when was control changed */
--#define SNDRV_CTL_ELEM_ACCESS_TLV_READ		(1<<4)	/* TLV read is possible */
--#define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE		(1<<5)	/* TLV write is possible */
--#define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE	(SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
--#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND	(1<<6)	/* TLV command is possible */
--#define SNDRV_CTL_ELEM_ACCESS_INACTIVE		(1<<8)	/* control does actually nothing, but may be updated */
--#define SNDRV_CTL_ELEM_ACCESS_LOCK		(1<<9)	/* write lock */
--#define SNDRV_CTL_ELEM_ACCESS_OWNER		(1<<10)	/* write lock owner */
--#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK	(1<<28)	/* kernel use a TLV callback */
--#define SNDRV_CTL_ELEM_ACCESS_USER		(1<<29) /* user space element */
--/* bits 30 and 31 are obsoleted (for indirect access) */
--
--/* for further details see the ACPI and PCI power management specification */
--#define SNDRV_CTL_POWER_D0		0x0000	/* full On */
--#define SNDRV_CTL_POWER_D1		0x0100	/* partial On */
--#define SNDRV_CTL_POWER_D2		0x0200	/* partial On */
--#define SNDRV_CTL_POWER_D3		0x0300	/* Off */
--#define SNDRV_CTL_POWER_D3hot		(SNDRV_CTL_POWER_D3|0x0000)	/* Off, with power */
--#define SNDRV_CTL_POWER_D3cold		(SNDRV_CTL_POWER_D3|0x0001)	/* Off, without power */
--
--#define SNDRV_CTL_ELEM_ID_NAME_MAXLEN	44
--
--struct snd_ctl_elem_id {
--	unsigned int numid;		/* numeric identifier, zero = invalid */
--	snd_ctl_elem_iface_t iface;	/* interface identifier */
--	unsigned int device;		/* device/client number */
--	unsigned int subdevice;		/* subdevice (substream) number */
--	unsigned char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];		/* ASCII name of item */
--	unsigned int index;		/* index of item */
--};
--
--struct snd_ctl_elem_list {
--	unsigned int offset;		/* W: first element ID to get */
--	unsigned int space;		/* W: count of element IDs to get */
--	unsigned int used;		/* R: count of element IDs set */
--	unsigned int count;		/* R: count of all elements */
--	struct snd_ctl_elem_id __user *pids; /* R: IDs */
--	unsigned char reserved[50];
--};
--
--struct snd_ctl_elem_info {
--	struct snd_ctl_elem_id id;	/* W: element ID */
--	snd_ctl_elem_type_t type;	/* R: value type - SNDRV_CTL_ELEM_TYPE_* */
--	unsigned int access;		/* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */
--	unsigned int count;		/* count of values */
--	__kernel_pid_t owner;		/* owner's PID of this control */
--	union {
--		struct {
--			long min;		/* R: minimum value */
--			long max;		/* R: maximum value */
--			long step;		/* R: step (0 variable) */
--		} integer;
--		struct {
--			long long min;		/* R: minimum value */
--			long long max;		/* R: maximum value */
--			long long step;		/* R: step (0 variable) */
--		} integer64;
--		struct {
--			unsigned int items;	/* R: number of items */
--			unsigned int item;	/* W: item number */
--			char name[64];		/* R: value name */
--			__u64 names_ptr;	/* W: names list (ELEM_ADD only) */
--			unsigned int names_length;
--		} enumerated;
--		unsigned char reserved[128];
--	} value;
--	union {
--		unsigned short d[4];		/* dimensions */
--		unsigned short *d_ptr;		/* indirect - obsoleted */
--	} dimen;
--	unsigned char reserved[64-4*sizeof(unsigned short)];
--};
--
--struct snd_ctl_elem_value {
--	struct snd_ctl_elem_id id;	/* W: element ID */
--	unsigned int indirect: 1;	/* W: indirect access - obsoleted */
--	union {
--		union {
--			long value[128];
--			long *value_ptr;	/* obsoleted */
--		} integer;
--		union {
--			long long value[64];
--			long long *value_ptr;	/* obsoleted */
--		} integer64;
--		union {
--			unsigned int item[128];
--			unsigned int *item_ptr;	/* obsoleted */
--		} enumerated;
--		union {
--			unsigned char data[512];
--			unsigned char *data_ptr;	/* obsoleted */
--		} bytes;
--		struct snd_aes_iec958 iec958;
--	} value;		/* RO */
--	struct timespec tstamp;
--	unsigned char reserved[128-sizeof(struct timespec)];
--};
--
--struct snd_ctl_tlv {
--	unsigned int numid;	/* control element numeric identification */
--	unsigned int length;	/* in bytes aligned to 4 */
--	unsigned int tlv[0];	/* first TLV */
--};
--
--#define SNDRV_CTL_IOCTL_PVERSION	_IOR('U', 0x00, int)
--#define SNDRV_CTL_IOCTL_CARD_INFO	_IOR('U', 0x01, struct snd_ctl_card_info)
--#define SNDRV_CTL_IOCTL_ELEM_LIST	_IOWR('U', 0x10, struct snd_ctl_elem_list)
--#define SNDRV_CTL_IOCTL_ELEM_INFO	_IOWR('U', 0x11, struct snd_ctl_elem_info)
--#define SNDRV_CTL_IOCTL_ELEM_READ	_IOWR('U', 0x12, struct snd_ctl_elem_value)
--#define SNDRV_CTL_IOCTL_ELEM_WRITE	_IOWR('U', 0x13, struct snd_ctl_elem_value)
--#define SNDRV_CTL_IOCTL_ELEM_LOCK	_IOW('U', 0x14, struct snd_ctl_elem_id)
--#define SNDRV_CTL_IOCTL_ELEM_UNLOCK	_IOW('U', 0x15, struct snd_ctl_elem_id)
--#define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int)
--#define SNDRV_CTL_IOCTL_ELEM_ADD	_IOWR('U', 0x17, struct snd_ctl_elem_info)
--#define SNDRV_CTL_IOCTL_ELEM_REPLACE	_IOWR('U', 0x18, struct snd_ctl_elem_info)
--#define SNDRV_CTL_IOCTL_ELEM_REMOVE	_IOWR('U', 0x19, struct snd_ctl_elem_id)
--#define SNDRV_CTL_IOCTL_TLV_READ	_IOWR('U', 0x1a, struct snd_ctl_tlv)
--#define SNDRV_CTL_IOCTL_TLV_WRITE	_IOWR('U', 0x1b, struct snd_ctl_tlv)
--#define SNDRV_CTL_IOCTL_TLV_COMMAND	_IOWR('U', 0x1c, struct snd_ctl_tlv)
--#define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int)
--#define SNDRV_CTL_IOCTL_HWDEP_INFO	_IOR('U', 0x21, struct snd_hwdep_info)
--#define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE	_IOR('U', 0x30, int)
--#define SNDRV_CTL_IOCTL_PCM_INFO	_IOWR('U', 0x31, struct snd_pcm_info)
--#define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int)
--#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_POWER		_IOWR('U', 0xd0, int)
--#define SNDRV_CTL_IOCTL_POWER_STATE	_IOR('U', 0xd1, int)
--
--/*
-- *  Read interface.
-- */
--
--enum sndrv_ctl_event_type {
--	SNDRV_CTL_EVENT_ELEM = 0,
--	SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM,
--};
--
--#define SNDRV_CTL_EVENT_MASK_VALUE	(1<<0)	/* element value was changed */
--#define SNDRV_CTL_EVENT_MASK_INFO	(1<<1)	/* element info was changed */
--#define SNDRV_CTL_EVENT_MASK_ADD	(1<<2)	/* element was added */
--#define SNDRV_CTL_EVENT_MASK_TLV	(1<<3)	/* element TLV tree was changed */
--#define SNDRV_CTL_EVENT_MASK_REMOVE	(~0U)	/* element was removed */
--
--struct snd_ctl_event {
--	int type;	/* event type - SNDRV_CTL_EVENT_* */
--	union {
--		struct {
--			unsigned int mask;
--			struct snd_ctl_elem_id id;
--		} elem;
--		unsigned char data8[60];
--	} data;
--};
--
--/*
-- *  Control names
-- */
--
--#define SNDRV_CTL_NAME_NONE				""
--#define SNDRV_CTL_NAME_PLAYBACK				"Playback "
--#define SNDRV_CTL_NAME_CAPTURE				"Capture "
--
--#define SNDRV_CTL_NAME_IEC958_NONE			""
--#define SNDRV_CTL_NAME_IEC958_SWITCH			"Switch"
--#define SNDRV_CTL_NAME_IEC958_VOLUME			"Volume"
--#define SNDRV_CTL_NAME_IEC958_DEFAULT			"Default"
--#define SNDRV_CTL_NAME_IEC958_MASK			"Mask"
--#define SNDRV_CTL_NAME_IEC958_CON_MASK			"Con Mask"
--#define SNDRV_CTL_NAME_IEC958_PRO_MASK			"Pro Mask"
--#define SNDRV_CTL_NAME_IEC958_PCM_STREAM		"PCM Stream"
--#define SNDRV_CTL_NAME_IEC958(expl,direction,what)	"IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what
--
--#endif /* _UAPI__SOUND_ASOUND_H */
-+#include <alsa/sound/uapi/asound.h>
-diff --git a/include/sound/asound_fm.h b/include/sound/asound_fm.h
-index 8471f404..3e5da4d0 100644
---- a/include/sound/asound_fm.h
-+++ b/include/sound/asound_fm.h
-@@ -1,135 +1 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--#ifndef __SOUND_ASOUND_FM_H
--#define __SOUND_ASOUND_FM_H
--
--/*
-- *  Advanced Linux Sound Architecture - ALSA
-- *
-- *  Interface file between ALSA driver & user space
-- *  Copyright (c) 1994-98 by Jaroslav Kysela <perex@perex.cz>,
-- *                           4Front Technologies
-- *
-- *  Direct FM control
-- *
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-- *
-- */
--
--#define SNDRV_DM_FM_MODE_OPL2	0x00
--#define SNDRV_DM_FM_MODE_OPL3	0x01
--
--struct snd_dm_fm_info {
--	unsigned char fm_mode;		/* OPL mode, see SNDRV_DM_FM_MODE_XXX */
--	unsigned char rhythm;		/* percussion mode flag */
--};
--
--/*
-- *  Data structure composing an FM "note" or sound event.
-- */
--
--struct snd_dm_fm_voice {
--	unsigned char op;		/* operator cell (0 or 1) */
--	unsigned char voice;		/* FM voice (0 to 17) */
--
--	unsigned char am;		/* amplitude modulation */
--	unsigned char vibrato;		/* vibrato effect */
--	unsigned char do_sustain;	/* sustain phase */
--	unsigned char kbd_scale;	/* keyboard scaling */
--	unsigned char harmonic;		/* 4 bits: harmonic and multiplier */
--	unsigned char scale_level;	/* 2 bits: decrease output freq rises */
--	unsigned char volume;		/* 6 bits: volume */
--
--	unsigned char attack;		/* 4 bits: attack rate */
--	unsigned char decay;		/* 4 bits: decay rate */
--	unsigned char sustain;		/* 4 bits: sustain level */
--	unsigned char release;		/* 4 bits: release rate */
--
--	unsigned char feedback;		/* 3 bits: feedback for op0 */
--	unsigned char connection;	/* 0 for serial, 1 for parallel */
--	unsigned char left;		/* stereo left */
--	unsigned char right;		/* stereo right */
--	unsigned char waveform;		/* 3 bits: waveform shape */
--};
--
--/*
-- *  This describes an FM note by its voice, octave, frequency number (10bit)
-- *  and key on/off.
-- */
--
--struct snd_dm_fm_note {
--	unsigned char voice;	/* 0-17 voice channel */
--	unsigned char octave;	/* 3 bits: what octave to play */
--	unsigned int fnum;	/* 10 bits: frequency number */
--	unsigned char key_on;	/* set for active, clear for silent */
--};
--
--/*
-- *  FM parameters that apply globally to all voices, and thus are not "notes"
-- */
--
--struct snd_dm_fm_params {
--	unsigned char am_depth;		/* amplitude modulation depth (1=hi) */
--	unsigned char vib_depth;	/* vibrato depth (1=hi) */
--	unsigned char kbd_split;	/* keyboard split */
--	unsigned char rhythm;		/* percussion mode select */
--
--	/* This block is the percussion instrument data */
--	unsigned char bass;
--	unsigned char snare;
--	unsigned char tomtom;
--	unsigned char cymbal;
--	unsigned char hihat;
--};
--
--/*
-- *  FM mode ioctl settings
-- */
--
--#define SNDRV_DM_FM_IOCTL_INFO		_IOR('H', 0x20, struct snd_dm_fm_info)
--#define SNDRV_DM_FM_IOCTL_RESET		_IO ('H', 0x21)
--#define SNDRV_DM_FM_IOCTL_PLAY_NOTE	_IOW('H', 0x22, struct snd_dm_fm_note)
--#define SNDRV_DM_FM_IOCTL_SET_VOICE	_IOW('H', 0x23, struct snd_dm_fm_voice)
--#define SNDRV_DM_FM_IOCTL_SET_PARAMS	_IOW('H', 0x24, struct snd_dm_fm_params)
--#define SNDRV_DM_FM_IOCTL_SET_MODE	_IOW('H', 0x25, int)
--/* for OPL3 only */
--#define SNDRV_DM_FM_IOCTL_SET_CONNECTION	_IOW('H', 0x26, int)
--/* SBI patch management */
--#define SNDRV_DM_FM_IOCTL_CLEAR_PATCHES	_IO ('H', 0x40)
--
--#define SNDRV_DM_FM_OSS_IOCTL_RESET		0x20
--#define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE		0x21
--#define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE		0x22
--#define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS	0x23
--#define SNDRV_DM_FM_OSS_IOCTL_SET_MODE		0x24
--#define SNDRV_DM_FM_OSS_IOCTL_SET_OPL		0x25
--
--/*
-- * Patch Record - fixed size for write
-- */
--
--#define FM_KEY_SBI	"SBI\032"
--#define FM_KEY_2OP	"2OP\032"
--#define FM_KEY_4OP	"4OP\032"
--
--struct sbi_patch {
--	unsigned char prog;
--	unsigned char bank;
--	char key[4];
--	char name[25];
--	char extension[7];
--	unsigned char data[32];
--};
--
--#endif /* __SOUND_ASOUND_FM_H */
-+#include <alsa/sound/uapi/asound_fm.h>
-diff --git a/include/sound/emu10k1.h b/include/sound/emu10k1.h
-index 042c5a6f..f06ecee5 100644
---- a/include/sound/emu10k1.h
-+++ b/include/sound/emu10k1.h
-@@ -1,381 +1,2 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--/*
-- *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
-- *		     Creative Labs, Inc.
-- *  Definitions for EMU10K1 (SB Live!) chips
-- *
-- *
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-- *
-- */
--#ifndef _UAPI__SOUND_EMU10K1_H
--#define _UAPI__SOUND_EMU10K1_H
--
--#include <linux/types.h>
--#include <sound/asound.h>
--
--/*
-- * ---- FX8010 ----
-- */
--
--#define EMU10K1_CARD_CREATIVE			0x00000000
--#define EMU10K1_CARD_EMUAPS			0x00000001
--
--#define EMU10K1_FX8010_PCM_COUNT		8
--
--/*
-- * Following definition is copied from linux/types.h to support compiling
-- * this header file in userspace since they are not generally available for
-- * uapi headers.
-- */
--#define __EMU10K1_DECLARE_BITMAP(name,bits) \
--	unsigned long name[(bits) / (sizeof(unsigned long) * 8)]
--
--/* instruction set */
--#define iMAC0	 0x00	/* R = A + (X * Y >> 31)   ; saturation */
--#define iMAC1	 0x01	/* R = A + (-X * Y >> 31)  ; saturation */
--#define iMAC2	 0x02	/* R = A + (X * Y >> 31)   ; wraparound */
--#define iMAC3	 0x03	/* R = A + (-X * Y >> 31)  ; wraparound */
--#define iMACINT0 0x04	/* R = A + X * Y	   ; saturation */
--#define iMACINT1 0x05	/* R = A + X * Y	   ; wraparound (31-bit) */
--#define iACC3	 0x06	/* R = A + X + Y	   ; saturation */
--#define iMACMV   0x07	/* R = A, acc += X * Y >> 31 */
--#define iANDXOR  0x08	/* R = (A & X) ^ Y */
--#define iTSTNEG  0x09	/* R = (A >= Y) ? X : ~X */
--#define iLIMITGE 0x0a	/* R = (A >= Y) ? X : Y */
--#define iLIMITLT 0x0b	/* R = (A < Y) ? X : Y */
--#define iLOG	 0x0c	/* R = linear_data, A (log_data), X (max_exp), Y (format_word) */
--#define iEXP	 0x0d	/* R = log_data, A (linear_data), X (max_exp), Y (format_word) */
--#define iINTERP  0x0e	/* R = A + (X * (Y - A) >> 31)  ; saturation */
--#define iSKIP    0x0f	/* R = A (cc_reg), X (count), Y (cc_test) */
--
--/* GPRs */
--#define FXBUS(x)	(0x00 + (x))	/* x = 0x00 - 0x0f */
--#define EXTIN(x)	(0x10 + (x))	/* x = 0x00 - 0x0f */
--#define EXTOUT(x)	(0x20 + (x))	/* x = 0x00 - 0x0f physical outs -> FXWC low 16 bits */
--#define FXBUS2(x)	(0x30 + (x))	/* x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits */
--					/* NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 */
--
--#define C_00000000	0x40
--#define C_00000001	0x41
--#define C_00000002	0x42
--#define C_00000003	0x43
--#define C_00000004	0x44
--#define C_00000008	0x45
--#define C_00000010	0x46
--#define C_00000020	0x47
--#define C_00000100	0x48
--#define C_00010000	0x49
--#define C_00080000	0x4a
--#define C_10000000	0x4b
--#define C_20000000	0x4c
--#define C_40000000	0x4d
--#define C_80000000	0x4e
--#define C_7fffffff	0x4f
--#define C_ffffffff	0x50
--#define C_fffffffe	0x51
--#define C_c0000000	0x52
--#define C_4f1bbcdc	0x53
--#define C_5a7ef9db	0x54
--#define C_00100000	0x55		/* ?? */
--#define GPR_ACCU	0x56		/* ACCUM, accumulator */
--#define GPR_COND	0x57		/* CCR, condition register */
--#define GPR_NOISE0	0x58		/* noise source */
--#define GPR_NOISE1	0x59		/* noise source */
--#define GPR_IRQ		0x5a		/* IRQ register */
--#define GPR_DBAC	0x5b		/* TRAM Delay Base Address Counter */
--#define GPR(x)		(FXGPREGBASE + (x)) /* free GPRs: x = 0x00 - 0xff */
--#define ITRAM_DATA(x)	(TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */
--#define ETRAM_DATA(x)	(TANKMEMDATAREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */
--#define ITRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */
--#define ETRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */
--
--#define A_ITRAM_DATA(x)	(TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
--#define A_ETRAM_DATA(x)	(TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
--#define A_ITRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
--#define A_ETRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
--#define A_ITRAM_CTL(x)	(A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
--#define A_ETRAM_CTL(x)	(A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
--
--#define A_FXBUS(x)	(0x00 + (x))	/* x = 0x00 - 0x3f FX buses */
--#define A_EXTIN(x)	(0x40 + (x))	/* x = 0x00 - 0x0f physical ins */
--#define A_P16VIN(x)	(0x50 + (x))	/* x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" */
--#define A_EXTOUT(x)	(0x60 + (x))	/* x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown   */
--#define A_FXBUS2(x)	(0x80 + (x))	/* x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 */
--#define A_EMU32OUTH(x)	(0xa0 + (x))	/* x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" - ??? */
--#define A_EMU32OUTL(x)	(0xb0 + (x))	/* x = 0x00 - 0x0f "EMU32_OUT_1 - _F" - ??? */
--#define A3_EMU32IN(x)	(0x160 + (x))	/* x = 0x00 - 0x3f "EMU32_IN_00 - _3F" - Only when .device = 0x0008 */
--#define A3_EMU32OUT(x)	(0x1E0 + (x))	/* x = 0x00 - 0x0f "EMU32_OUT_00 - _3F" - Only when .device = 0x0008 */
--#define A_GPR(x)	(A_FXGPREGBASE + (x))
--
--/* cc_reg constants */
--#define CC_REG_NORMALIZED C_00000001
--#define CC_REG_BORROW	C_00000002
--#define CC_REG_MINUS	C_00000004
--#define CC_REG_ZERO	C_00000008
--#define CC_REG_SATURATE	C_00000010
--#define CC_REG_NONZERO	C_00000100
--
--/* FX buses */
--#define FXBUS_PCM_LEFT		0x00
--#define FXBUS_PCM_RIGHT		0x01
--#define FXBUS_PCM_LEFT_REAR	0x02
--#define FXBUS_PCM_RIGHT_REAR	0x03
--#define FXBUS_MIDI_LEFT		0x04
--#define FXBUS_MIDI_RIGHT	0x05
--#define FXBUS_PCM_CENTER	0x06
--#define FXBUS_PCM_LFE		0x07
--#define FXBUS_PCM_LEFT_FRONT	0x08
--#define FXBUS_PCM_RIGHT_FRONT	0x09
--#define FXBUS_MIDI_REVERB	0x0c
--#define FXBUS_MIDI_CHORUS	0x0d
--#define FXBUS_PCM_LEFT_SIDE	0x0e
--#define FXBUS_PCM_RIGHT_SIDE	0x0f
--#define FXBUS_PT_LEFT		0x14
--#define FXBUS_PT_RIGHT		0x15
--
--/* Inputs */
--#define EXTIN_AC97_L	   0x00	/* AC'97 capture channel - left */
--#define EXTIN_AC97_R	   0x01	/* AC'97 capture channel - right */
--#define EXTIN_SPDIF_CD_L   0x02	/* internal S/PDIF CD - onboard - left */
--#define EXTIN_SPDIF_CD_R   0x03	/* internal S/PDIF CD - onboard - right */
--#define EXTIN_ZOOM_L	   0x04	/* Zoom Video I2S - left */
--#define EXTIN_ZOOM_R	   0x05	/* Zoom Video I2S - right */
--#define EXTIN_TOSLINK_L	   0x06	/* LiveDrive - TOSLink Optical - left */
--#define EXTIN_TOSLINK_R    0x07	/* LiveDrive - TOSLink Optical - right */
--#define EXTIN_LINE1_L	   0x08	/* LiveDrive - Line/Mic 1 - left */
--#define EXTIN_LINE1_R	   0x09	/* LiveDrive - Line/Mic 1 - right */
--#define EXTIN_COAX_SPDIF_L 0x0a	/* LiveDrive - Coaxial S/PDIF - left */
--#define EXTIN_COAX_SPDIF_R 0x0b /* LiveDrive - Coaxial S/PDIF - right */
--#define EXTIN_LINE2_L	   0x0c	/* LiveDrive - Line/Mic 2 - left */
--#define EXTIN_LINE2_R	   0x0d	/* LiveDrive - Line/Mic 2 - right */
--
--/* Outputs */
--#define EXTOUT_AC97_L	   0x00	/* AC'97 playback channel - left */
--#define EXTOUT_AC97_R	   0x01	/* AC'97 playback channel - right */
--#define EXTOUT_TOSLINK_L   0x02	/* LiveDrive - TOSLink Optical - left */
--#define EXTOUT_TOSLINK_R   0x03	/* LiveDrive - TOSLink Optical - right */
--#define EXTOUT_AC97_CENTER 0x04	/* SB Live 5.1 - center */
--#define EXTOUT_AC97_LFE	   0x05 /* SB Live 5.1 - LFE */
--#define EXTOUT_HEADPHONE_L 0x06	/* LiveDrive - Headphone - left */
--#define EXTOUT_HEADPHONE_R 0x07	/* LiveDrive - Headphone - right */
--#define EXTOUT_REAR_L	   0x08	/* Rear channel - left */
--#define EXTOUT_REAR_R	   0x09	/* Rear channel - right */
--#define EXTOUT_ADC_CAP_L   0x0a	/* ADC Capture buffer - left */
--#define EXTOUT_ADC_CAP_R   0x0b	/* ADC Capture buffer - right */
--#define EXTOUT_MIC_CAP	   0x0c	/* MIC Capture buffer */
--#define EXTOUT_AC97_REAR_L 0x0d	/* SB Live 5.1 (c) 2003 - Rear Left */
--#define EXTOUT_AC97_REAR_R 0x0e	/* SB Live 5.1 (c) 2003 - Rear Right */
--#define EXTOUT_ACENTER	   0x11 /* Analog Center */
--#define EXTOUT_ALFE	   0x12 /* Analog LFE */
--
--/* Audigy Inputs */
--#define A_EXTIN_AC97_L		0x00	/* AC'97 capture channel - left */
--#define A_EXTIN_AC97_R		0x01	/* AC'97 capture channel - right */
--#define A_EXTIN_SPDIF_CD_L	0x02	/* digital CD left */
--#define A_EXTIN_SPDIF_CD_R	0x03	/* digital CD left */
--#define A_EXTIN_OPT_SPDIF_L     0x04    /* audigy drive Optical SPDIF - left */
--#define A_EXTIN_OPT_SPDIF_R     0x05    /*                              right */ 
--#define A_EXTIN_LINE2_L		0x08	/* audigy drive line2/mic2 - left */
--#define A_EXTIN_LINE2_R		0x09	/*                           right */
--#define A_EXTIN_ADC_L		0x0a    /* Philips ADC - left */
--#define A_EXTIN_ADC_R		0x0b    /*               right */
--#define A_EXTIN_AUX2_L		0x0c	/* audigy drive aux2 - left */
--#define A_EXTIN_AUX2_R		0x0d	/*                   - right */
--
--/* Audigiy Outputs */
--#define A_EXTOUT_FRONT_L	0x00	/* digital front left */
--#define A_EXTOUT_FRONT_R	0x01	/*               right */
--#define A_EXTOUT_CENTER		0x02	/* digital front center */
--#define A_EXTOUT_LFE		0x03	/* digital front lfe */
--#define A_EXTOUT_HEADPHONE_L	0x04	/* headphone audigy drive left */
--#define A_EXTOUT_HEADPHONE_R	0x05	/*                        right */
--#define A_EXTOUT_REAR_L		0x06	/* digital rear left */
--#define A_EXTOUT_REAR_R		0x07	/*              right */
--#define A_EXTOUT_AFRONT_L	0x08	/* analog front left */
--#define A_EXTOUT_AFRONT_R	0x09	/*              right */
--#define A_EXTOUT_ACENTER	0x0a	/* analog center */
--#define A_EXTOUT_ALFE		0x0b	/* analog LFE */
--#define A_EXTOUT_ASIDE_L	0x0c	/* analog side left  - Audigy 2 ZS */
--#define A_EXTOUT_ASIDE_R	0x0d	/*             right - Audigy 2 ZS */
--#define A_EXTOUT_AREAR_L	0x0e	/* analog rear left */
--#define A_EXTOUT_AREAR_R	0x0f	/*             right */
--#define A_EXTOUT_AC97_L		0x10	/* AC97 left (front) */
--#define A_EXTOUT_AC97_R		0x11	/*      right */
--#define A_EXTOUT_ADC_CAP_L	0x16	/* ADC capture buffer left */
--#define A_EXTOUT_ADC_CAP_R	0x17	/*                    right */
--#define A_EXTOUT_MIC_CAP	0x18	/* Mic capture buffer */
--
--/* Audigy constants */
--#define A_C_00000000	0xc0
--#define A_C_00000001	0xc1
--#define A_C_00000002	0xc2
--#define A_C_00000003	0xc3
--#define A_C_00000004	0xc4
--#define A_C_00000008	0xc5
--#define A_C_00000010	0xc6
--#define A_C_00000020	0xc7
--#define A_C_00000100	0xc8
--#define A_C_00010000	0xc9
--#define A_C_00000800	0xca
--#define A_C_10000000	0xcb
--#define A_C_20000000	0xcc
--#define A_C_40000000	0xcd
--#define A_C_80000000	0xce
--#define A_C_7fffffff	0xcf
--#define A_C_ffffffff	0xd0
--#define A_C_fffffffe	0xd1
--#define A_C_c0000000	0xd2
--#define A_C_4f1bbcdc	0xd3
--#define A_C_5a7ef9db	0xd4
--#define A_C_00100000	0xd5
--#define A_GPR_ACCU	0xd6		/* ACCUM, accumulator */
--#define A_GPR_COND	0xd7		/* CCR, condition register */
--#define A_GPR_NOISE0	0xd8		/* noise source */
--#define A_GPR_NOISE1	0xd9		/* noise source */
--#define A_GPR_IRQ	0xda		/* IRQ register */
--#define A_GPR_DBAC	0xdb		/* TRAM Delay Base Address Counter - internal */
--#define A_GPR_DBACE	0xde		/* TRAM Delay Base Address Counter - external */
--
--/* definitions for debug register */
--#define EMU10K1_DBG_ZC			0x80000000	/* zero tram counter */
--#define EMU10K1_DBG_SATURATION_OCCURED	0x02000000	/* saturation control */
--#define EMU10K1_DBG_SATURATION_ADDR	0x01ff0000	/* saturation address */
--#define EMU10K1_DBG_SINGLE_STEP		0x00008000	/* single step mode */
--#define EMU10K1_DBG_STEP		0x00004000	/* start single step */
--#define EMU10K1_DBG_CONDITION_CODE	0x00003e00	/* condition code */
--#define EMU10K1_DBG_SINGLE_STEP_ADDR	0x000001ff	/* single step address */
--
--/* tank memory address line */
--#ifndef __KERNEL__
--#define TANKMEMADDRREG_ADDR_MASK 0x000fffff	/* 20 bit tank address field			*/
--#define TANKMEMADDRREG_CLEAR	 0x00800000	/* Clear tank memory				*/
--#define TANKMEMADDRREG_ALIGN	 0x00400000	/* Align read or write relative to tank access	*/
--#define TANKMEMADDRREG_WRITE	 0x00200000	/* Write to tank memory				*/
--#define TANKMEMADDRREG_READ	 0x00100000	/* Read from tank memory			*/
--#endif
--
--struct snd_emu10k1_fx8010_info {
--	unsigned int internal_tram_size;	/* in samples */
--	unsigned int external_tram_size;	/* in samples */
--	char fxbus_names[16][32];		/* names of FXBUSes */
--	char extin_names[16][32];		/* names of external inputs */
--	char extout_names[32][32];		/* names of external outputs */
--	unsigned int gpr_controls;		/* count of GPR controls */
--};
--
--#define EMU10K1_GPR_TRANSLATION_NONE		0
--#define EMU10K1_GPR_TRANSLATION_TABLE100	1
--#define EMU10K1_GPR_TRANSLATION_BASS		2
--#define EMU10K1_GPR_TRANSLATION_TREBLE		3
--#define EMU10K1_GPR_TRANSLATION_ONOFF		4
--
--struct snd_emu10k1_fx8010_control_gpr {
--	struct snd_ctl_elem_id id;		/* full control ID definition */
--	unsigned int vcount;		/* visible count */
--	unsigned int count;		/* count of GPR (1..16) */
--	unsigned short gpr[32];		/* GPR number(s) */
--	unsigned int value[32];		/* initial values */
--	unsigned int min;		/* minimum range */
--	unsigned int max;		/* maximum range */
--	unsigned int translation;	/* translation type (EMU10K1_GPR_TRANSLATION*) */
--	const unsigned int *tlv;
--};
--
--/* old ABI without TLV support */
--struct snd_emu10k1_fx8010_control_old_gpr {
--	struct snd_ctl_elem_id id;
--	unsigned int vcount;
--	unsigned int count;
--	unsigned short gpr[32];
--	unsigned int value[32];
--	unsigned int min;
--	unsigned int max;
--	unsigned int translation;
--};
--
--struct snd_emu10k1_fx8010_code {
--	char name[128];
--
--	__EMU10K1_DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */
--	__u32 __user *gpr_map;		/* initializers */
--
--	unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */
--	struct snd_emu10k1_fx8010_control_gpr __user *gpr_add_controls; /* GPR controls to add/replace */
--
--	unsigned int gpr_del_control_count; /* count of GPR controls to remove */
--	struct snd_ctl_elem_id __user *gpr_del_controls; /* IDs of GPR controls to remove */
--
--	unsigned int gpr_list_control_count; /* count of GPR controls to list */
--	unsigned int gpr_list_control_total; /* total count of GPR controls */
--	struct snd_emu10k1_fx8010_control_gpr __user *gpr_list_controls; /* listed GPR controls */
--
--	__EMU10K1_DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */
--	__u32 __user *tram_data_map;	  /* data initializers */
--	__u32 __user *tram_addr_map;	  /* map initializers */
--
--	__EMU10K1_DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */
--	__u32 __user *code;		  /* one instruction - 64 bits */
--};
--
--struct snd_emu10k1_fx8010_tram {
--	unsigned int address;		/* 31.bit == 1 -> external TRAM */
--	unsigned int size;		/* size in samples (4 bytes) */
--	unsigned int *samples;		/* pointer to samples (20-bit) */
--					/* NULL->clear memory */
--};
--
--struct snd_emu10k1_fx8010_pcm_rec {
--	unsigned int substream;		/* substream number */
--	unsigned int res1;		/* reserved */
--	unsigned int channels;		/* 16-bit channels count, zero = remove this substream */
--	unsigned int tram_start;	/* ring buffer position in TRAM (in samples) */
--	unsigned int buffer_size;	/* count of buffered samples */
--	unsigned short gpr_size;		/* GPR containing size of ringbuffer in samples (host) */
--	unsigned short gpr_ptr;		/* GPR containing current pointer in the ring buffer (host = reset, FX8010) */
--	unsigned short gpr_count;	/* GPR containing count of samples between two interrupts (host) */
--	unsigned short gpr_tmpcount;	/* GPR containing current count of samples to interrupt (host = set, FX8010) */
--	unsigned short gpr_trigger;	/* GPR containing trigger (activate) information (host) */
--	unsigned short gpr_running;	/* GPR containing info if PCM is running (FX8010) */
--	unsigned char pad;		/* reserved */
--	unsigned char etram[32];	/* external TRAM address & data (one per channel) */
--	unsigned int res2;		/* reserved */
--};
--
--#define SNDRV_EMU10K1_VERSION		SNDRV_PROTOCOL_VERSION(1, 0, 1)
--
--#define SNDRV_EMU10K1_IOCTL_INFO	_IOR ('H', 0x10, struct snd_emu10k1_fx8010_info)
--#define SNDRV_EMU10K1_IOCTL_CODE_POKE	_IOW ('H', 0x11, struct snd_emu10k1_fx8010_code)
--#define SNDRV_EMU10K1_IOCTL_CODE_PEEK	_IOWR('H', 0x12, struct snd_emu10k1_fx8010_code)
--#define SNDRV_EMU10K1_IOCTL_TRAM_SETUP	_IOW ('H', 0x20, int)
--#define SNDRV_EMU10K1_IOCTL_TRAM_POKE	_IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram)
--#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK	_IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram)
--#define SNDRV_EMU10K1_IOCTL_PCM_POKE	_IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec)
--#define SNDRV_EMU10K1_IOCTL_PCM_PEEK	_IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec)
--#define SNDRV_EMU10K1_IOCTL_PVERSION	_IOR ('H', 0x40, int)
--#define SNDRV_EMU10K1_IOCTL_STOP	_IO  ('H', 0x80)
--#define SNDRV_EMU10K1_IOCTL_CONTINUE	_IO  ('H', 0x81)
--#define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82)
--#define SNDRV_EMU10K1_IOCTL_SINGLE_STEP	_IOW ('H', 0x83, int)
--#define SNDRV_EMU10K1_IOCTL_DBG_READ	_IOR ('H', 0x84, int)
--
--/* typedefs for compatibility to user-space */
--typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t;
--typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t;
--typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t;
--typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t;
--typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t;
--
--#endif /* _UAPI__SOUND_EMU10K1_H */
-+#include <alsa/sound/type_compat.h>
-+#include <alsa/sound/uapi/emu10k1.h>
-diff --git a/include/sound/hdsp.h b/include/sound/hdsp.h
-index 5dc0c3db..78fb745b 100644
---- a/include/sound/hdsp.h
-+++ b/include/sound/hdsp.h
-@@ -1,111 +1,2 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--#ifndef __SOUND_HDSP_H
--#define __SOUND_HDSP_H
--
--/*
-- *   Copyright (C) 2003 Thomas Charbonnel (thomas@undata.org)
-- *    
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-- */
--
--#include <linux/types.h>
--
--#define HDSP_MATRIX_MIXER_SIZE 2048
--
--enum HDSP_IO_Type {
--	Digiface,
--	Multiface,
--	H9652,
--	H9632,
--	RPM,
--	Undefined,
--};
--
--struct hdsp_peak_rms {
--	__u32 input_peaks[26];
--	__u32 playback_peaks[26];
--	__u32 output_peaks[28];
--	__u64 input_rms[26];
--	__u64 playback_rms[26];
--	/* These are only used for H96xx cards */
--	__u64 output_rms[26];
--};
--
--#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms)
--
--struct hdsp_config_info {
--	unsigned char pref_sync_ref;
--	unsigned char wordclock_sync_check;
--	unsigned char spdif_sync_check;
--	unsigned char adatsync_sync_check;
--	unsigned char adat_sync_check[3];
--	unsigned char spdif_in;
--	unsigned char spdif_out;
--	unsigned char spdif_professional;
--	unsigned char spdif_emphasis;
--	unsigned char spdif_nonaudio;
--	unsigned int spdif_sample_rate;
--	unsigned int system_sample_rate;
--	unsigned int autosync_sample_rate;
--	unsigned char system_clock_mode;
--	unsigned char clock_source;
--	unsigned char autosync_ref;
--	unsigned char line_out;
--	unsigned char passthru; 
--	unsigned char da_gain;
--	unsigned char ad_gain;
--	unsigned char phone_gain;
--	unsigned char xlr_breakout_cable;
--	unsigned char analog_extension_board;
--};
--
--#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info)
--
--struct hdsp_firmware {
--	void __user *firmware_data;	/* 24413 x 4 bytes */
--};
--
--#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware)
--
--struct hdsp_version {
--	enum HDSP_IO_Type io_type;
--	unsigned short firmware_rev;
--};
--
--#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version)
--
--struct hdsp_mixer {
--	unsigned short matrix[HDSP_MATRIX_MIXER_SIZE];
--};
--
--#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer)
--
--struct hdsp_9632_aeb {
--	int aebi;
--	int aebo;
--};
--
--#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb)
--
--/* typedefs for compatibility to user-space */
--typedef enum HDSP_IO_Type HDSP_IO_Type;
--typedef struct hdsp_peak_rms hdsp_peak_rms_t;
--typedef struct hdsp_config_info hdsp_config_info_t;
--typedef struct hdsp_firmware hdsp_firmware_t;
--typedef struct hdsp_version hdsp_version_t;
--typedef struct hdsp_mixer hdsp_mixer_t;
--typedef struct hdsp_9632_aeb hdsp_9632_aeb_t;
--
--#endif /* __SOUND_HDSP_H */
-+#include <alsa/sound/type_compat.h>
-+#include <alsa/sound/uapi/hdsp.h>
-diff --git a/include/sound/hdspm.h b/include/sound/hdspm.h
-index a38f3f79..af6d19ed 100644
---- a/include/sound/hdspm.h
-+++ b/include/sound/hdspm.h
-@@ -1,232 +1,2 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--#ifndef __SOUND_HDSPM_H
--#define __SOUND_HDSPM_H
--/*
-- *   Copyright (C) 2003 Winfried Ritsch (IEM)
-- *   based on hdsp.h from Thomas Charbonnel (thomas@undata.org)
-- *
-- *
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-- */
--
--#include <linux/types.h>
--
--/* Maximum channels is 64 even on 56Mode you have 64playbacks to matrix */
--#define HDSPM_MAX_CHANNELS      64
--
--enum hdspm_io_type {
--	MADI,
--	MADIface,
--	AIO,
--	AES32,
--	RayDAT
--};
--
--enum hdspm_speed {
--	ss,
--	ds,
--	qs
--};
--
--/* -------------------- IOCTL Peak/RMS Meters -------------------- */
--
--struct hdspm_peak_rms {
--	__u32 input_peaks[64];
--	__u32 playback_peaks[64];
--	__u32 output_peaks[64];
--
--	__u64 input_rms[64];
--	__u64 playback_rms[64];
--	__u64 output_rms[64];
--
--	__u8 speed; /* enum {ss, ds, qs} */
--	int status2;
--};
--
--#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS \
--	_IOR('H', 0x42, struct hdspm_peak_rms)
--
--/* ------------ CONFIG block IOCTL ---------------------- */
--
--struct hdspm_config {
--	unsigned char pref_sync_ref;
--	unsigned char wordclock_sync_check;
--	unsigned char madi_sync_check;
--	unsigned int system_sample_rate;
--	unsigned int autosync_sample_rate;
--	unsigned char system_clock_mode;
--	unsigned char clock_source;
--	unsigned char autosync_ref;
--	unsigned char line_out;
--	unsigned int passthru;
--	unsigned int analog_out;
--};
--
--#define SNDRV_HDSPM_IOCTL_GET_CONFIG \
--	_IOR('H', 0x41, struct hdspm_config)
--
--/*
-- * If there's a TCO (TimeCode Option) board installed,
-- * there are further options and status data available.
-- * The hdspm_ltc structure contains the current SMPTE
-- * timecode and some status information and can be
-- * obtained via SNDRV_HDSPM_IOCTL_GET_LTC or in the
-- * hdspm_status struct.
-- */
--
--enum hdspm_ltc_format {
--	format_invalid,
--	fps_24,
--	fps_25,
--	fps_2997,
--	fps_30
--};
--
--enum hdspm_ltc_frame {
--	frame_invalid,
--	drop_frame,
--	full_frame
--};
--
--enum hdspm_ltc_input_format {
--	ntsc,
--	pal,
--	no_video
--};
--
--struct hdspm_ltc {
--	unsigned int ltc;
--
--	enum hdspm_ltc_format format;
--	enum hdspm_ltc_frame frame;
--	enum hdspm_ltc_input_format input_format;
--};
--
--#define SNDRV_HDSPM_IOCTL_GET_LTC _IOR('H', 0x46, struct hdspm_ltc)
--
--/*
-- * The status data reflects the device's current state
-- * as determined by the card's configuration and
-- * connection status.
-- */
--
--enum hdspm_sync {
--	hdspm_sync_no_lock = 0,
--	hdspm_sync_lock = 1,
--	hdspm_sync_sync = 2
--};
--
--enum hdspm_madi_input {
--	hdspm_input_optical = 0,
--	hdspm_input_coax = 1
--};
--
--enum hdspm_madi_channel_format {
--	hdspm_format_ch_64 = 0,
--	hdspm_format_ch_56 = 1
--};
--
--enum hdspm_madi_frame_format {
--	hdspm_frame_48 = 0,
--	hdspm_frame_96 = 1
--};
--
--enum hdspm_syncsource {
--	syncsource_wc = 0,
--	syncsource_madi = 1,
--	syncsource_tco = 2,
--	syncsource_sync = 3,
--	syncsource_none = 4
--};
--
--struct hdspm_status {
--	__u8 card_type; /* enum hdspm_io_type */
--	enum hdspm_syncsource autosync_source;
--
--	__u64 card_clock;
--	__u32 master_period;
--
--	union {
--		struct {
--			__u8 sync_wc; /* enum hdspm_sync */
--			__u8 sync_madi; /* enum hdspm_sync */
--			__u8 sync_tco; /* enum hdspm_sync */
--			__u8 sync_in; /* enum hdspm_sync */
--			__u8 madi_input; /* enum hdspm_madi_input */
--			__u8 channel_format; /* enum hdspm_madi_channel_format */
--			__u8 frame_format; /* enum hdspm_madi_frame_format */
--		} madi;
--	} card_specific;
--};
--
--#define SNDRV_HDSPM_IOCTL_GET_STATUS \
--	_IOR('H', 0x47, struct hdspm_status)
--
--/*
-- * Get information about the card and its add-ons.
-- */
--
--#define HDSPM_ADDON_TCO 1
--
--struct hdspm_version {
--	__u8 card_type; /* enum hdspm_io_type */
--	char cardname[20];
--	unsigned int serial;
--	unsigned short firmware_rev;
--	int addons;
--};
--
--#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x48, struct hdspm_version)
--
--/* ------------- get Matrix Mixer IOCTL --------------- */
--
--/* MADI mixer: 64inputs+64playback in 64outputs = 8192 => *4Byte =
-- * 32768 Bytes
-- */
--
--/* organisation is 64 channelfader in a continuous memory block */
--/* equivalent to hardware definition, maybe for future feature of mmap of
-- * them
-- */
--/* each of 64 outputs has 64 infader and 64 outfader:
--   Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] */
--
--#define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS
--
--struct hdspm_channelfader {
--	unsigned int in[HDSPM_MIXER_CHANNELS];
--	unsigned int pb[HDSPM_MIXER_CHANNELS];
--};
--
--struct hdspm_mixer {
--	struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS];
--};
--
--struct hdspm_mixer_ioctl {
--	struct hdspm_mixer *mixer;
--};
--
--/* use indirect access due to the limit of ioctl bit size */
--#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl)
--
--/* typedefs for compatibility to user-space */
--typedef struct hdspm_peak_rms hdspm_peak_rms_t;
--typedef struct hdspm_config_info hdspm_config_info_t;
--typedef struct hdspm_version hdspm_version_t;
--typedef struct hdspm_channelfader snd_hdspm_channelfader_t;
--typedef struct hdspm_mixer hdspm_mixer_t;
--
--
--#endif
-+#include <alsa/sound/type_compat.h>
-+#include <alsa/sound/uapi/hdspm.h>
-diff --git a/include/sound/sb16_csp.h b/include/sound/sb16_csp.h
-index e6485148..24121fcb 100644
---- a/include/sound/sb16_csp.h
-+++ b/include/sound/sb16_csp.h
-@@ -1,123 +1 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--/*
-- *  Copyright (c) 1999 by Uros Bizjak <uros@kss-loka.si>
-- *                        Takashi Iwai <tiwai@suse.de>
-- *
-- *  SB16ASP/AWE32 CSP control
-- *
-- *   This program is free software; you can redistribute it and/or modify 
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- *
-- *   You should have received a copy of the GNU General Public License
-- *   along with this program; if not, write to the Free Software
-- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-- *
-- */
--#ifndef _UAPI__SOUND_SB16_CSP_H
--#define _UAPI__SOUND_SB16_CSP_H
--
--
--/* CSP modes */
--#define SNDRV_SB_CSP_MODE_NONE		0x00
--#define SNDRV_SB_CSP_MODE_DSP_READ	0x01	/* Record from DSP */
--#define SNDRV_SB_CSP_MODE_DSP_WRITE	0x02	/* Play to DSP */
--#define SNDRV_SB_CSP_MODE_QSOUND		0x04	/* QSound */
--
--/* CSP load flags */
--#define SNDRV_SB_CSP_LOAD_FROMUSER	0x01
--#define SNDRV_SB_CSP_LOAD_INITBLOCK	0x02
--
--/* CSP sample width */
--#define SNDRV_SB_CSP_SAMPLE_8BIT		0x01
--#define SNDRV_SB_CSP_SAMPLE_16BIT		0x02
--
--/* CSP channels */
--#define SNDRV_SB_CSP_MONO			0x01
--#define SNDRV_SB_CSP_STEREO		0x02
--
--/* CSP rates */
--#define SNDRV_SB_CSP_RATE_8000		0x01
--#define SNDRV_SB_CSP_RATE_11025		0x02
--#define SNDRV_SB_CSP_RATE_22050		0x04
--#define SNDRV_SB_CSP_RATE_44100		0x08
--#define SNDRV_SB_CSP_RATE_ALL		0x0f
--
--/* CSP running state */
--#define SNDRV_SB_CSP_ST_IDLE		0x00
--#define SNDRV_SB_CSP_ST_LOADED		0x01
--#define SNDRV_SB_CSP_ST_RUNNING		0x02
--#define SNDRV_SB_CSP_ST_PAUSED		0x04
--#define SNDRV_SB_CSP_ST_AUTO		0x08
--#define SNDRV_SB_CSP_ST_QSOUND		0x10
--
--/* maximum QSound value (180 degrees right) */
--#define SNDRV_SB_CSP_QSOUND_MAX_RIGHT	0x20
--
--/* maximum microcode RIFF file size */
--#define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE	0x3000
--
--/* microcode header */
--struct snd_sb_csp_mc_header {
--	char codec_name[16];		/* id name of codec */
--	unsigned short func_req;	/* requested function */
--};
--
--/* microcode to be loaded */
--struct snd_sb_csp_microcode {
--	struct snd_sb_csp_mc_header info;
--	unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE];
--};
--
--/* start CSP with sample_width in mono/stereo */
--struct snd_sb_csp_start {
--	int sample_width;	/* sample width, look above */
--	int channels;		/* channels, look above */
--};
--
--/* CSP information */
--struct snd_sb_csp_info {
--	char codec_name[16];		/* id name of codec */
--	unsigned short func_nr;		/* function number */
--	unsigned int acc_format;	/* accepted PCM formats */
--	unsigned short acc_channels;	/* accepted channels */
--	unsigned short acc_width;	/* accepted sample width */
--	unsigned short acc_rates;	/* accepted sample rates */
--	unsigned short csp_mode;	/* CSP mode, see above */
--	unsigned short run_channels;	/* current channels  */
--	unsigned short run_width;	/* current sample width */
--	unsigned short version;		/* version id: 0x10 - 0x1f */
--	unsigned short state;		/* state bits */
--};
--
--/* HWDEP controls */
--/* get CSP information */
--#define SNDRV_SB_CSP_IOCTL_INFO		_IOR('H', 0x10, struct snd_sb_csp_info)
--/* load microcode to CSP */
--/* NOTE: struct snd_sb_csp_microcode overflows the max size (13 bits)
-- * defined for some architectures like MIPS, and it leads to build errors.
-- * (x86 and co have 14-bit size, thus it's valid, though.)
-- * As a workaround for skipping the size-limit check, here we don't use the
-- * normal _IOW() macro but _IOC() with the manual argument.
-- */
--#define SNDRV_SB_CSP_IOCTL_LOAD_CODE	\
--	_IOC(_IOC_WRITE, 'H', 0x11, sizeof(struct snd_sb_csp_microcode))
--/* unload microcode from CSP */
--#define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE	_IO('H', 0x12)
--/* start CSP */
--#define SNDRV_SB_CSP_IOCTL_START		_IOW('H', 0x13, struct snd_sb_csp_start)
--/* stop CSP */
--#define SNDRV_SB_CSP_IOCTL_STOP		_IO('H', 0x14)
--/* pause CSP and DMA transfer */
--#define SNDRV_SB_CSP_IOCTL_PAUSE		_IO('H', 0x15)
--/* restart CSP and DMA transfer */
--#define SNDRV_SB_CSP_IOCTL_RESTART	_IO('H', 0x16)
--
--
--#endif /* _UAPI__SOUND_SB16_CSP_H */
-+#include <alsa/sound/uapi/sb16_csp.h>
-diff --git a/include/sound/sscape_ioctl.h b/include/sound/sscape_ioctl.h
-index c6653ebf..23b48d33 100644
---- a/include/sound/sscape_ioctl.h
-+++ b/include/sound/sscape_ioctl.h
-@@ -1,21 +1 @@
--#ifndef SSCAPE_IOCTL_H
--#define SSCAPE_IOCTL_H
--
--
--struct sscape_bootblock
--{
--  unsigned char code[256];
--  unsigned version;
--};
--
--#define SSCAPE_MICROCODE_SIZE  65536
--
--struct sscape_microcode
--{
--  unsigned char *code;
--};
--
--#define SND_SSCAPE_LOAD_BOOTB  _IOWR('P', 100, struct sscape_bootblock)
--#define SND_SSCAPE_LOAD_MCODE  _IOW ('P', 101, struct sscape_microcode)
--
--#endif
-+#include <alsa/sound/uapi/sscape_ioctl.h>
-diff --git a/include/sound/tlv.h b/include/sound/tlv.h
-index 7d6d65f6..e435a5fc 100644
---- a/include/sound/tlv.h
-+++ b/include/sound/tlv.h
-@@ -1,117 +1 @@
--/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
--/*
-- *   This program is free software; you can redistribute it and/or modify
-- *   it under the terms of the GNU General Public License as published by
-- *   the Free Software Foundation; either version 2 of the License, or
-- *   (at your option) any later version.
-- *
-- *   This program is distributed in the hope that it will be useful,
-- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- *   GNU General Public License for more details.
-- */
--
--#ifndef __UAPI_SOUND_TLV_H
--#define __UAPI_SOUND_TLV_H
--
--#define SNDRV_CTL_TLVT_CONTAINER 0	/* one level down - group of TLVs */
--#define SNDRV_CTL_TLVT_DB_SCALE	1       /* dB scale */
--#define SNDRV_CTL_TLVT_DB_LINEAR 2	/* linear volume */
--#define SNDRV_CTL_TLVT_DB_RANGE 3	/* dB range container */
--#define SNDRV_CTL_TLVT_DB_MINMAX 4	/* dB scale with min/max */
--#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5	/* dB scale with min/max with mute */
--
--/*
-- * channel-mapping TLV items
-- *  TLV length must match with num_channels
-- */
--#define SNDRV_CTL_TLVT_CHMAP_FIXED	0x101	/* fixed channel position */
--#define SNDRV_CTL_TLVT_CHMAP_VAR	0x102	/* channels freely swappable */
--#define SNDRV_CTL_TLVT_CHMAP_PAIRED	0x103	/* pair-wise swappable */
--
--/*
-- * TLV structure is right behind the struct snd_ctl_tlv:
-- *   unsigned int type  	- see SNDRV_CTL_TLVT_*
-- *   unsigned int length
-- *   .... data aligned to sizeof(unsigned int), use
-- *        block_length = (length + (sizeof(unsigned int) - 1)) &
-- *                       ~(sizeof(unsigned int) - 1)) ....
-- */
--#define SNDRV_CTL_TLVD_ITEM(type, ...) \
--	(type), SNDRV_CTL_TLVD_LENGTH(__VA_ARGS__), __VA_ARGS__
--#define SNDRV_CTL_TLVD_LENGTH(...) \
--	((unsigned int)sizeof((const unsigned int[]) { __VA_ARGS__ }))
--
--/* Accessor offsets for TLV data items */
--#define SNDRV_CTL_TLVO_TYPE		0
--#define SNDRV_CTL_TLVO_LEN		1
--
--#define SNDRV_CTL_TLVD_CONTAINER_ITEM(...) \
--	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_CONTAINER, __VA_ARGS__)
--#define SNDRV_CTL_TLVD_DECLARE_CONTAINER(name, ...) \
--	unsigned int name[] = { \
--		SNDRV_CTL_TLVD_CONTAINER_ITEM(__VA_ARGS__) \
--	}
--
--#define SNDRV_CTL_TLVD_DB_SCALE_MASK	0xffff
--#define SNDRV_CTL_TLVD_DB_SCALE_MUTE	0x10000
--#define SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \
--	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_SCALE, \
--			    (min), \
--			    ((step) & SNDRV_CTL_TLVD_DB_SCALE_MASK) | \
--			     ((mute) ? SNDRV_CTL_TLVD_DB_SCALE_MUTE : 0))
--#define SNDRV_CTL_TLVD_DECLARE_DB_SCALE(name, min, step, mute) \
--	unsigned int name[] = { \
--		SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \
--	}
--
--/* Accessor offsets for min, mute and step items in dB scale type TLV */
--#define SNDRV_CTL_TLVO_DB_SCALE_MIN		2
--#define SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP	3
--
--/* dB scale specified with min/max values instead of step */
--#define SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \
--	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX, (min_dB), (max_dB))
--#define SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \
--	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX_MUTE, (min_dB), (max_dB))
--#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(name, min_dB, max_dB) \
--	unsigned int name[] = { \
--		SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \
--	}
--#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE(name, min_dB, max_dB) \
--	unsigned int name[] = { \
--		SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \
--	}
--
--/* Accessor offsets for min, max items in db-minmax types of TLV. */
--#define SNDRV_CTL_TLVO_DB_MINMAX_MIN	2
--#define SNDRV_CTL_TLVO_DB_MINMAX_MAX	3
--
--/* linear volume between min_dB and max_dB (.01dB unit) */
--#define SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \
--	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_LINEAR, (min_dB), (max_dB))
--#define SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(name, min_dB, max_dB) \
--	unsigned int name[] = { \
--		SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \
--	}
--
--/* Accessor offsets for min, max items in db-linear type of TLV. */
--#define SNDRV_CTL_TLVO_DB_LINEAR_MIN	2
--#define SNDRV_CTL_TLVO_DB_LINEAR_MAX	3
--
--/* dB range container:
-- * Items in dB range container must be ordered by their values and by their
-- * dB values. This implies that larger values must correspond with larger
-- * dB values (which is also required for all other mixer controls).
-- */
--/* Each item is: <min> <max> <TLV> */
--#define SNDRV_CTL_TLVD_DB_RANGE_ITEM(...) \
--	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_RANGE, __VA_ARGS__)
--#define SNDRV_CTL_TLVD_DECLARE_DB_RANGE(name, ...) \
--	unsigned int name[] = { \
--		SNDRV_CTL_TLVD_DB_RANGE_ITEM(__VA_ARGS__) \
--	}
--
--#define SNDRV_CTL_TLVD_DB_GAIN_MUTE	-9999999
--
--#endif
-+#include <alsa/sound/uapi/tlv.h>
-diff --git a/include/sound/type_compat.h b/include/sound/type_compat.h
-index e973ff31..d4790c1f 100644
---- a/include/sound/type_compat.h
-+++ b/include/sound/type_compat.h
-@@ -3,6 +3,9 @@
- 
- #ifndef DOC_HIDDEN
- #include <stdint.h>
-+#ifdef __linux__
-+#include <linux/types.h>
-+#else
- typedef uint8_t __u8;
- typedef uint16_t __u16;
- typedef uint32_t __u32;
-@@ -37,6 +40,16 @@ typedef int32_t __s32;
- #define __be32 __u32
- #define __be16 __u16
- #define __be8  __u8
-+#endif
-+
-+#ifndef __user
-+#define __user
-+#endif
-+
-+#ifndef __packed
-+#define __packed __attribute__((__packed__))
-+#endif
-+
- #endif /* DOC_HIDDEN */
- 
- #endif /* __TYPE_COMPAT_H */
-diff --git a/include/sound/uapi/Makefile.am b/include/sound/uapi/Makefile.am
-new file mode 100644
-index 00000000..99197108
---- /dev/null
-+++ b/include/sound/uapi/Makefile.am
-@@ -0,0 +1,6 @@
-+alsasounduapiincludedir = ${includedir}/alsa/sound/uapi
-+
-+alsasounduapiinclude_HEADERS = asound_fm.h hdsp.h hdspm.h sb16_csp.h \
-+			   sscape_ioctl.h emu10k1.h asoc.h tlv.h
-+
-+noinst_HEADERS = asound.h asequencer.h
-diff --git a/include/sound/uapi/asequencer.h b/include/sound/uapi/asequencer.h
-new file mode 100644
-index 00000000..a75e14ed
---- /dev/null
-+++ b/include/sound/uapi/asequencer.h
-@@ -0,0 +1,612 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+/*
-+ *  Main header file for the ALSA sequencer
-+ *  Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
-+ *            (c) 1998-1999 by Jaroslav Kysela <perex@perex.cz>
-+ *
-+ *
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-+ *
-+ */
-+#ifndef _UAPI__SOUND_ASEQUENCER_H
-+#define _UAPI__SOUND_ASEQUENCER_H
-+
-+#include <sound/asound.h>
-+
-+/** version of the sequencer */
-+#define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 2)
-+
-+/**
-+ * definition of sequencer event types
-+ */
-+
-+/** system messages
-+ * event data type = #snd_seq_result
-+ */
-+#define SNDRV_SEQ_EVENT_SYSTEM		0
-+#define SNDRV_SEQ_EVENT_RESULT		1
-+
-+/** note messages (channel specific)
-+ * event data type = #snd_seq_ev_note
-+ */
-+#define SNDRV_SEQ_EVENT_NOTE		5
-+#define SNDRV_SEQ_EVENT_NOTEON		6
-+#define SNDRV_SEQ_EVENT_NOTEOFF		7
-+#define SNDRV_SEQ_EVENT_KEYPRESS	8
-+	
-+/** control messages (channel specific)
-+ * event data type = #snd_seq_ev_ctrl
-+ */
-+#define SNDRV_SEQ_EVENT_CONTROLLER	10
-+#define SNDRV_SEQ_EVENT_PGMCHANGE	11
-+#define SNDRV_SEQ_EVENT_CHANPRESS	12
-+#define SNDRV_SEQ_EVENT_PITCHBEND	13	/**< from -8192 to 8191 */
-+#define SNDRV_SEQ_EVENT_CONTROL14	14	/**< 14 bit controller value */
-+#define SNDRV_SEQ_EVENT_NONREGPARAM	15	/**< 14 bit NRPN address + 14 bit unsigned value */
-+#define SNDRV_SEQ_EVENT_REGPARAM	16	/**< 14 bit RPN address + 14 bit unsigned value */
-+
-+/** synchronisation messages
-+ * event data type = #snd_seq_ev_ctrl
-+ */
-+#define SNDRV_SEQ_EVENT_SONGPOS		20	/* Song Position Pointer with LSB and MSB values */
-+#define SNDRV_SEQ_EVENT_SONGSEL		21	/* Song Select with song ID number */
-+#define SNDRV_SEQ_EVENT_QFRAME		22	/* midi time code quarter frame */
-+#define SNDRV_SEQ_EVENT_TIMESIGN	23	/* SMF Time Signature event */
-+#define SNDRV_SEQ_EVENT_KEYSIGN		24	/* SMF Key Signature event */
-+	        
-+/** timer messages
-+ * event data type = snd_seq_ev_queue_control
-+ */
-+#define SNDRV_SEQ_EVENT_START		30	/* midi Real Time Start message */
-+#define SNDRV_SEQ_EVENT_CONTINUE	31	/* midi Real Time Continue message */
-+#define SNDRV_SEQ_EVENT_STOP		32	/* midi Real Time Stop message */	
-+#define	SNDRV_SEQ_EVENT_SETPOS_TICK	33	/* set tick queue position */
-+#define SNDRV_SEQ_EVENT_SETPOS_TIME	34	/* set realtime queue position */
-+#define SNDRV_SEQ_EVENT_TEMPO		35	/* (SMF) Tempo event */
-+#define SNDRV_SEQ_EVENT_CLOCK		36	/* midi Real Time Clock message */
-+#define SNDRV_SEQ_EVENT_TICK		37	/* midi Real Time Tick message */
-+#define SNDRV_SEQ_EVENT_QUEUE_SKEW	38	/* skew queue tempo */
-+
-+/** others
-+ * event data type = none
-+ */
-+#define SNDRV_SEQ_EVENT_TUNE_REQUEST	40	/* tune request */
-+#define SNDRV_SEQ_EVENT_RESET		41	/* reset to power-on state */
-+#define SNDRV_SEQ_EVENT_SENSING		42	/* "active sensing" event */
-+
-+/** echo back, kernel private messages
-+ * event data type = any type
-+ */
-+#define SNDRV_SEQ_EVENT_ECHO		50	/* echo event */
-+#define SNDRV_SEQ_EVENT_OSS		51	/* OSS raw event */
-+
-+/** system status messages (broadcast for subscribers)
-+ * event data type = snd_seq_addr
-+ */
-+#define SNDRV_SEQ_EVENT_CLIENT_START	60	/* new client has connected */
-+#define SNDRV_SEQ_EVENT_CLIENT_EXIT	61	/* client has left the system */
-+#define SNDRV_SEQ_EVENT_CLIENT_CHANGE	62	/* client status/info has changed */
-+#define SNDRV_SEQ_EVENT_PORT_START	63	/* new port was created */
-+#define SNDRV_SEQ_EVENT_PORT_EXIT	64	/* port was deleted from system */
-+#define SNDRV_SEQ_EVENT_PORT_CHANGE	65	/* port status/info has changed */
-+
-+/** port connection changes
-+ * event data type = snd_seq_connect
-+ */
-+#define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED	66	/* ports connected */
-+#define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67	/* ports disconnected */
-+
-+/* 70-89:  synthesizer events - obsoleted */
-+
-+/** user-defined events with fixed length
-+ * event data type = any
-+ */
-+#define SNDRV_SEQ_EVENT_USR0		90
-+#define SNDRV_SEQ_EVENT_USR1		91
-+#define SNDRV_SEQ_EVENT_USR2		92
-+#define SNDRV_SEQ_EVENT_USR3		93
-+#define SNDRV_SEQ_EVENT_USR4		94
-+#define SNDRV_SEQ_EVENT_USR5		95
-+#define SNDRV_SEQ_EVENT_USR6		96
-+#define SNDRV_SEQ_EVENT_USR7		97
-+#define SNDRV_SEQ_EVENT_USR8		98
-+#define SNDRV_SEQ_EVENT_USR9		99
-+
-+/* 100-118: instrument layer - obsoleted */
-+/* 119-129: reserved */
-+
-+/* 130-139: variable length events
-+ * event data type = snd_seq_ev_ext
-+ * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set)
-+ */
-+#define SNDRV_SEQ_EVENT_SYSEX		130	/* system exclusive data (variable length) */
-+#define SNDRV_SEQ_EVENT_BOUNCE		131	/* error event */
-+/* 132-134: reserved */
-+#define SNDRV_SEQ_EVENT_USR_VAR0	135
-+#define SNDRV_SEQ_EVENT_USR_VAR1	136
-+#define SNDRV_SEQ_EVENT_USR_VAR2	137
-+#define SNDRV_SEQ_EVENT_USR_VAR3	138
-+#define SNDRV_SEQ_EVENT_USR_VAR4	139
-+
-+/* 150-151: kernel events with quote - DO NOT use in user clients */
-+#define SNDRV_SEQ_EVENT_KERNEL_ERROR	150
-+#define SNDRV_SEQ_EVENT_KERNEL_QUOTE	151	/* obsolete */
-+
-+/* 152-191: reserved */
-+
-+/* 192-254: hardware specific events */
-+
-+/* 255: special event */
-+#define SNDRV_SEQ_EVENT_NONE		255
-+
-+
-+typedef unsigned char snd_seq_event_type_t;
-+
-+/** event address */
-+struct snd_seq_addr {
-+	unsigned char client;	/**< Client number:         0..255, 255 = broadcast to all clients */
-+	unsigned char port;	/**< Port within client:    0..255, 255 = broadcast to all ports */
-+};
-+
-+/** port connection */
-+struct snd_seq_connect {
-+	struct snd_seq_addr sender;
-+	struct snd_seq_addr dest;
-+};
-+
-+
-+#define SNDRV_SEQ_ADDRESS_UNKNOWN	253	/* unknown source */
-+#define SNDRV_SEQ_ADDRESS_SUBSCRIBERS	254	/* send event to all subscribed ports */
-+#define SNDRV_SEQ_ADDRESS_BROADCAST	255	/* send event to all queues/clients/ports/channels */
-+#define SNDRV_SEQ_QUEUE_DIRECT		253	/* direct dispatch */
-+
-+	/* event mode flag - NOTE: only 8 bits available! */
-+#define SNDRV_SEQ_TIME_STAMP_TICK	(0<<0) /* timestamp in clock ticks */
-+#define SNDRV_SEQ_TIME_STAMP_REAL	(1<<0) /* timestamp in real time */
-+#define SNDRV_SEQ_TIME_STAMP_MASK	(1<<0)
-+
-+#define SNDRV_SEQ_TIME_MODE_ABS		(0<<1)	/* absolute timestamp */
-+#define SNDRV_SEQ_TIME_MODE_REL		(1<<1)	/* relative to current time */
-+#define SNDRV_SEQ_TIME_MODE_MASK	(1<<1)
-+
-+#define SNDRV_SEQ_EVENT_LENGTH_FIXED	(0<<2)	/* fixed event size */
-+#define SNDRV_SEQ_EVENT_LENGTH_VARIABLE	(1<<2)	/* variable event size */
-+#define SNDRV_SEQ_EVENT_LENGTH_VARUSR	(2<<2)	/* variable event size - user memory space */
-+#define SNDRV_SEQ_EVENT_LENGTH_MASK	(3<<2)
-+
-+#define SNDRV_SEQ_PRIORITY_NORMAL	(0<<4)	/* normal priority */
-+#define SNDRV_SEQ_PRIORITY_HIGH		(1<<4)	/* event should be processed before others */
-+#define SNDRV_SEQ_PRIORITY_MASK		(1<<4)
-+
-+
-+	/* note event */
-+struct snd_seq_ev_note {
-+	unsigned char channel;
-+	unsigned char note;
-+	unsigned char velocity;
-+	unsigned char off_velocity;	/* only for SNDRV_SEQ_EVENT_NOTE */
-+	unsigned int duration;		/* only for SNDRV_SEQ_EVENT_NOTE */
-+};
-+
-+	/* controller event */
-+struct snd_seq_ev_ctrl {
-+	unsigned char channel;
-+	unsigned char unused1, unused2, unused3;	/* pad */
-+	unsigned int param;
-+	signed int value;
-+};
-+
-+	/* generic set of bytes (12x8 bit) */
-+struct snd_seq_ev_raw8 {
-+	unsigned char d[12];	/* 8 bit value */
-+};
-+
-+	/* generic set of integers (3x32 bit) */
-+struct snd_seq_ev_raw32 {
-+	unsigned int d[3];	/* 32 bit value */
-+};
-+
-+	/* external stored data */
-+struct snd_seq_ev_ext {
-+	unsigned int len;	/* length of data */
-+	void *ptr;		/* pointer to data (note: maybe 64-bit) */
-+} __attribute__((packed));
-+
-+struct snd_seq_result {
-+	int event;		/* processed event type */
-+	int result;
-+};
-+
-+
-+struct snd_seq_real_time {
-+	unsigned int tv_sec;	/* seconds */
-+	unsigned int tv_nsec;	/* nanoseconds */
-+};
-+
-+typedef unsigned int snd_seq_tick_time_t;	/* midi ticks */
-+
-+union snd_seq_timestamp {
-+	snd_seq_tick_time_t tick;
-+	struct snd_seq_real_time time;
-+};
-+
-+struct snd_seq_queue_skew {
-+	unsigned int value;
-+	unsigned int base;
-+};
-+
-+	/* queue timer control */
-+struct snd_seq_ev_queue_control {
-+	unsigned char queue;			/* affected queue */
-+	unsigned char pad[3];			/* reserved */
-+	union {
-+		signed int value;		/* affected value (e.g. tempo) */
-+		union snd_seq_timestamp time;	/* time */
-+		unsigned int position;		/* sync position */
-+		struct snd_seq_queue_skew skew;
-+		unsigned int d32[2];
-+		unsigned char d8[8];
-+	} param;
-+};
-+
-+	/* quoted event - inside the kernel only */
-+struct snd_seq_ev_quote {
-+	struct snd_seq_addr origin;		/* original sender */
-+	unsigned short value;		/* optional data */
-+	struct snd_seq_event *event;		/* quoted event */
-+} __attribute__((packed));
-+
-+
-+	/* sequencer event */
-+struct snd_seq_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 {				/* 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;
-+};
-+
-+
-+/*
-+ * bounce event - stored as variable size data
-+ */
-+struct snd_seq_event_bounce {
-+	int err;
-+	struct snd_seq_event event;
-+	/* external data follows here. */
-+};
-+
-+
-+	/* system information */
-+struct snd_seq_system_info {
-+	int queues;			/* maximum queues count */
-+	int clients;			/* maximum clients count */
-+	int ports;			/* maximum ports per client */
-+	int channels;			/* maximum channels per port */
-+	int cur_clients;		/* current clients */
-+	int cur_queues;			/* current queues */
-+	char reserved[24];
-+};
-+
-+
-+	/* system running information */
-+struct snd_seq_running_info {
-+	unsigned char client;		/* client id */
-+	unsigned char big_endian;	/* 1 = big-endian */
-+	unsigned char cpu_mode;		/* 4 = 32bit, 8 = 64bit */
-+	unsigned char pad;		/* reserved */
-+	unsigned char reserved[12];
-+};
-+
-+
-+	/* known client numbers */
-+#define SNDRV_SEQ_CLIENT_SYSTEM		0
-+	/* internal client numbers */
-+#define SNDRV_SEQ_CLIENT_DUMMY		14	/* midi through */
-+#define SNDRV_SEQ_CLIENT_OSS		15	/* oss sequencer emulator */
-+
-+
-+	/* client types */
-+typedef int __bitwise snd_seq_client_type_t;
-+#define	NO_CLIENT	((__force snd_seq_client_type_t) 0)
-+#define	USER_CLIENT	((__force snd_seq_client_type_t) 1)
-+#define	KERNEL_CLIENT	((__force snd_seq_client_type_t) 2)
-+                        
-+	/* event filter flags */
-+#define SNDRV_SEQ_FILTER_BROADCAST	(1<<0)	/* accept broadcast messages */
-+#define SNDRV_SEQ_FILTER_MULTICAST	(1<<1)	/* accept multicast messages */
-+#define SNDRV_SEQ_FILTER_BOUNCE		(1<<2)	/* accept bounce event in error */
-+#define SNDRV_SEQ_FILTER_USE_EVENT	(1<<31)	/* use event filter */
-+
-+struct snd_seq_client_info {
-+	int client;			/* client number to inquire */
-+	snd_seq_client_type_t type;	/* client type */
-+	char name[64];			/* client name */
-+	unsigned int filter;		/* filter flags */
-+	unsigned char multicast_filter[8]; /* multicast filter bitmap */
-+	unsigned char event_filter[32];	/* event filter bitmap */
-+	int num_ports;			/* RO: number of ports */
-+	int event_lost;			/* number of lost events */
-+	int card;			/* RO: card number[kernel] */
-+	int pid;			/* RO: pid[user] */
-+	char reserved[56];		/* for future use */
-+};
-+
-+
-+/* client pool size */
-+struct snd_seq_client_pool {
-+	int client;			/* client number to inquire */
-+	int output_pool;		/* outgoing (write) pool size */
-+	int input_pool;			/* incoming (read) pool size */
-+	int output_room;		/* minimum free pool size for select/blocking mode */
-+	int output_free;		/* unused size */
-+	int input_free;			/* unused size */
-+	char reserved[64];
-+};
-+
-+
-+/* Remove events by specified criteria */
-+
-+#define SNDRV_SEQ_REMOVE_INPUT		(1<<0)	/* Flush input queues */
-+#define SNDRV_SEQ_REMOVE_OUTPUT		(1<<1)	/* Flush output queues */
-+#define SNDRV_SEQ_REMOVE_DEST		(1<<2)	/* Restrict by destination q:client:port */
-+#define SNDRV_SEQ_REMOVE_DEST_CHANNEL	(1<<3)	/* Restrict by channel */
-+#define SNDRV_SEQ_REMOVE_TIME_BEFORE	(1<<4)	/* Restrict to before time */
-+#define SNDRV_SEQ_REMOVE_TIME_AFTER	(1<<5)	/* Restrict to time or after */
-+#define SNDRV_SEQ_REMOVE_TIME_TICK	(1<<6)	/* Time is in ticks */
-+#define SNDRV_SEQ_REMOVE_EVENT_TYPE	(1<<7)	/* Restrict to event type */
-+#define SNDRV_SEQ_REMOVE_IGNORE_OFF 	(1<<8)	/* Do not flush off events */
-+#define SNDRV_SEQ_REMOVE_TAG_MATCH 	(1<<9)	/* Restrict to events with given tag */
-+
-+struct snd_seq_remove_events {
-+	unsigned int  remove_mode;	/* Flags that determine what gets removed */
-+
-+	union snd_seq_timestamp time;
-+
-+	unsigned char queue;	/* Queue for REMOVE_DEST */
-+	struct snd_seq_addr dest;	/* Address for REMOVE_DEST */
-+	unsigned char channel;	/* Channel for REMOVE_DEST */
-+
-+	int  type;	/* For REMOVE_EVENT_TYPE */
-+	char  tag;	/* Tag for REMOVE_TAG */
-+
-+	int  reserved[10];	/* To allow for future binary compatibility */
-+
-+};
-+
-+
-+	/* known port numbers */
-+#define SNDRV_SEQ_PORT_SYSTEM_TIMER	0
-+#define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE	1
-+
-+	/* port capabilities (32 bits) */
-+#define SNDRV_SEQ_PORT_CAP_READ		(1<<0)	/* readable from this port */
-+#define SNDRV_SEQ_PORT_CAP_WRITE	(1<<1)	/* writable to this port */
-+
-+#define SNDRV_SEQ_PORT_CAP_SYNC_READ	(1<<2)
-+#define SNDRV_SEQ_PORT_CAP_SYNC_WRITE	(1<<3)
-+
-+#define SNDRV_SEQ_PORT_CAP_DUPLEX	(1<<4)
-+
-+#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 */
-+
-+	/* port type */
-+#define SNDRV_SEQ_PORT_TYPE_SPECIFIC	(1<<0)	/* hardware specific */
-+#define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1)	/* generic MIDI device */
-+#define SNDRV_SEQ_PORT_TYPE_MIDI_GM	(1<<2)	/* General MIDI compatible device */
-+#define SNDRV_SEQ_PORT_TYPE_MIDI_GS	(1<<3)	/* GS compatible device */
-+#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 */
-+
-+/* other standards...*/
-+#define SNDRV_SEQ_PORT_TYPE_SYNTH	(1<<10)	/* Synth device (no MIDI compatible - direct wavetable) */
-+#define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11)	/* Sampling device (support sample download) */
-+#define SNDRV_SEQ_PORT_TYPE_SAMPLE	(1<<12)	/* Sampling device (sample can be downloaded at any time) */
-+/*...*/
-+#define SNDRV_SEQ_PORT_TYPE_HARDWARE	(1<<16)	/* driver for a hardware device */
-+#define SNDRV_SEQ_PORT_TYPE_SOFTWARE	(1<<17)	/* implemented in software */
-+#define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER	(1<<18)	/* generates sound */
-+#define SNDRV_SEQ_PORT_TYPE_PORT	(1<<19)	/* connects to other device(s) */
-+#define SNDRV_SEQ_PORT_TYPE_APPLICATION	(1<<20)	/* application (sequencer/editor) */
-+
-+/* misc. conditioning flags */
-+#define SNDRV_SEQ_PORT_FLG_GIVEN_PORT	(1<<0)
-+#define SNDRV_SEQ_PORT_FLG_TIMESTAMP	(1<<1)
-+#define SNDRV_SEQ_PORT_FLG_TIME_REAL	(1<<2)
-+
-+struct snd_seq_port_info {
-+	struct snd_seq_addr addr;	/* client/port numbers */
-+	char name[64];			/* port name */
-+
-+	unsigned int capability;	/* port capability bits */
-+	unsigned int type;		/* port type bits */
-+	int midi_channels;		/* channels per MIDI port */
-+	int midi_voices;		/* voices per MIDI port */
-+	int synth_voices;		/* voices per SYNTH port */
-+
-+	int read_use;			/* R/O: subscribers for output (from this port) */
-+	int write_use;			/* R/O: subscribers for input (to this port) */
-+
-+	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 */
-+};
-+
-+
-+/* queue flags */
-+#define SNDRV_SEQ_QUEUE_FLG_SYNC	(1<<0)	/* sync enabled */
-+
-+/* queue information */
-+struct snd_seq_queue_info {
-+	int queue;		/* queue id */
-+
-+	/*
-+	 *  security settings, only owner of this queue can start/stop timer
-+	 *  etc. if the queue is locked for other clients
-+	 */
-+	int owner;		/* client id for owner of the queue */
-+	unsigned locked:1;	/* timing queue locked for other queues */
-+	char name[64];		/* name of this queue */
-+	unsigned int flags;	/* flags */
-+	char reserved[60];	/* for future use */
-+
-+};
-+
-+/* queue info/status */
-+struct snd_seq_queue_status {
-+	int queue;			/* queue id */
-+	int events;			/* read-only - queue size */
-+	snd_seq_tick_time_t tick;	/* current tick */
-+	struct snd_seq_real_time time;	/* current time */
-+	int running;			/* running state of queue */
-+	int flags;			/* various flags */
-+	char reserved[64];		/* for the future */
-+};
-+
-+
-+/* queue tempo */
-+struct snd_seq_queue_tempo {
-+	int queue;			/* sequencer queue */
-+	unsigned int tempo;		/* current tempo, us/tick */
-+	int ppq;			/* time resolution, ticks/quarter */
-+	unsigned int skew_value;	/* queue skew */
-+	unsigned int skew_base;		/* queue skew base */
-+	char reserved[24];		/* for the future */
-+};
-+
-+
-+/* sequencer timer sources */
-+#define SNDRV_SEQ_TIMER_ALSA		0	/* ALSA timer */
-+#define SNDRV_SEQ_TIMER_MIDI_CLOCK	1	/* Midi Clock (CLOCK event) */
-+#define SNDRV_SEQ_TIMER_MIDI_TICK	2	/* Midi Timer Tick (TICK event) */
-+
-+/* queue timer info */
-+struct snd_seq_queue_timer {
-+	int queue;			/* sequencer queue */
-+	int type;			/* source timer type */
-+	union {
-+		struct {
-+			struct snd_timer_id id;	/* ALSA's timer ID */
-+			unsigned int resolution;	/* resolution in Hz */
-+		} alsa;
-+	} u;
-+	char reserved[64];		/* for the future use */
-+};
-+
-+
-+struct snd_seq_queue_client {
-+	int queue;		/* sequencer queue */
-+	int client;		/* sequencer client */
-+	int used;		/* queue is used with this client
-+				   (must be set for accepting events) */
-+	/* per client watermarks */
-+	char reserved[64];	/* for future use */
-+};
-+
-+
-+#define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE	(1<<0)	/* exclusive connection */
-+#define SNDRV_SEQ_PORT_SUBS_TIMESTAMP	(1<<1)
-+#define SNDRV_SEQ_PORT_SUBS_TIME_REAL	(1<<2)
-+
-+struct snd_seq_port_subscribe {
-+	struct snd_seq_addr sender;	/* sender address */
-+	struct snd_seq_addr dest;	/* destination address */
-+	unsigned int voices;		/* number of voices to be allocated (0 = don't care) */
-+	unsigned int flags;		/* modes */
-+	unsigned char queue;		/* input time-stamp queue (optional) */
-+	unsigned char pad[3];		/* reserved */
-+	char reserved[64];
-+};
-+
-+/* type of query subscription */
-+#define SNDRV_SEQ_QUERY_SUBS_READ	0
-+#define SNDRV_SEQ_QUERY_SUBS_WRITE	1
-+
-+struct snd_seq_query_subs {
-+	struct snd_seq_addr root;	/* client/port id to be searched */
-+	int type;		/* READ or WRITE */
-+	int index;		/* 0..N-1 */
-+	int num_subs;		/* R/O: number of subscriptions on this port */
-+	struct snd_seq_addr addr;	/* R/O: result */
-+	unsigned char queue;	/* R/O: result */
-+	unsigned int flags;	/* R/O: result */
-+	char reserved[64];	/* for future use */
-+};
-+
-+
-+/*
-+ *  IOCTL commands
-+ */
-+
-+#define SNDRV_SEQ_IOCTL_PVERSION	_IOR ('S', 0x00, int)
-+#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_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_CREATE_PORT	_IOWR('S', 0x20, struct snd_seq_port_info)
-+#define SNDRV_SEQ_IOCTL_DELETE_PORT	_IOW ('S', 0x21, struct snd_seq_port_info)
-+#define SNDRV_SEQ_IOCTL_GET_PORT_INFO	_IOWR('S', 0x22, struct snd_seq_port_info)
-+#define SNDRV_SEQ_IOCTL_SET_PORT_INFO	_IOW ('S', 0x23, struct snd_seq_port_info)
-+
-+#define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT	_IOW ('S', 0x30, struct snd_seq_port_subscribe)
-+#define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe)
-+
-+#define SNDRV_SEQ_IOCTL_CREATE_QUEUE	_IOWR('S', 0x32, struct snd_seq_queue_info)
-+#define SNDRV_SEQ_IOCTL_DELETE_QUEUE	_IOW ('S', 0x33, struct snd_seq_queue_info)
-+#define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO	_IOWR('S', 0x34, struct snd_seq_queue_info)
-+#define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO	_IOWR('S', 0x35, struct snd_seq_queue_info)
-+#define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE	_IOWR('S', 0x36, struct snd_seq_queue_info)
-+#define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status)
-+#define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO	_IOWR('S', 0x41, struct snd_seq_queue_tempo)
-+#define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO	_IOW ('S', 0x42, struct snd_seq_queue_tempo)
-+#define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER	_IOWR('S', 0x45, struct snd_seq_queue_timer)
-+#define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER	_IOW ('S', 0x46, struct snd_seq_queue_timer)
-+#define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT	_IOWR('S', 0x49, struct snd_seq_queue_client)
-+#define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT	_IOW ('S', 0x4a, struct snd_seq_queue_client)
-+#define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL	_IOWR('S', 0x4b, struct snd_seq_client_pool)
-+#define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL	_IOW ('S', 0x4c, struct snd_seq_client_pool)
-+#define SNDRV_SEQ_IOCTL_REMOVE_EVENTS	_IOW ('S', 0x4e, struct snd_seq_remove_events)
-+#define SNDRV_SEQ_IOCTL_QUERY_SUBS	_IOWR('S', 0x4f, struct snd_seq_query_subs)
-+#define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION	_IOWR('S', 0x50, struct snd_seq_port_subscribe)
-+#define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT	_IOWR('S', 0x51, struct snd_seq_client_info)
-+#define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT	_IOWR('S', 0x52, struct snd_seq_port_info)
-+
-+#endif /* _UAPI__SOUND_ASEQUENCER_H */
-diff --git a/include/sound/uapi/asoc.h b/include/sound/uapi/asoc.h
-new file mode 100644
-index 00000000..a74ca232
---- /dev/null
-+++ b/include/sound/uapi/asoc.h
-@@ -0,0 +1,633 @@
-+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
-+/*
-+ * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM
-+ *
-+ * Copyright (C) 2012 Texas Instruments Inc.
-+ * Copyright (C) 2015 Intel Corporation.
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License version 2 as
-+ * published by the Free Software Foundation.
-+ *
-+ * Simple file API to load FW that includes mixers, coefficients, DAPM graphs,
-+ * algorithms, equalisers, DAIs, widgets etc.
-+*/
-+
-+#ifndef __LINUX_UAPI_SND_ASOC_H
-+#define __LINUX_UAPI_SND_ASOC_H
-+
-+#include <linux/types.h>
-+#include <sound/asound.h>
-+
-+/*
-+ * Maximum number of channels topology kcontrol can represent.
-+ */
-+#define SND_SOC_TPLG_MAX_CHAN		8
-+
-+/*
-+ * Maximum number of PCM formats capability
-+ */
-+#define SND_SOC_TPLG_MAX_FORMATS	16
-+
-+/*
-+ * Maximum number of PCM stream configs
-+ */
-+#define SND_SOC_TPLG_STREAM_CONFIG_MAX  8
-+
-+/*
-+ * Maximum number of physical link's hardware configs
-+ */
-+#define SND_SOC_TPLG_HW_CONFIG_MAX	8
-+
-+/* individual kcontrol info types - can be mixed with other types */
-+#define SND_SOC_TPLG_CTL_VOLSW		1
-+#define SND_SOC_TPLG_CTL_VOLSW_SX	2
-+#define SND_SOC_TPLG_CTL_VOLSW_XR_SX	3
-+#define SND_SOC_TPLG_CTL_ENUM		4
-+#define SND_SOC_TPLG_CTL_BYTES		5
-+#define SND_SOC_TPLG_CTL_ENUM_VALUE	6
-+#define SND_SOC_TPLG_CTL_RANGE		7
-+#define SND_SOC_TPLG_CTL_STROBE		8
-+
-+
-+/* individual widget kcontrol info types - can be mixed with other types */
-+#define SND_SOC_TPLG_DAPM_CTL_VOLSW		64
-+#define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE	65
-+#define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT		66
-+#define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE	67
-+#define SND_SOC_TPLG_DAPM_CTL_PIN		68
-+
-+/* DAPM widget types - add new items to the end */
-+#define SND_SOC_TPLG_DAPM_INPUT		0
-+#define SND_SOC_TPLG_DAPM_OUTPUT	1
-+#define SND_SOC_TPLG_DAPM_MUX		2
-+#define SND_SOC_TPLG_DAPM_MIXER		3
-+#define SND_SOC_TPLG_DAPM_PGA		4
-+#define SND_SOC_TPLG_DAPM_OUT_DRV	5
-+#define SND_SOC_TPLG_DAPM_ADC		6
-+#define SND_SOC_TPLG_DAPM_DAC		7
-+#define SND_SOC_TPLG_DAPM_SWITCH	8
-+#define SND_SOC_TPLG_DAPM_PRE		9
-+#define SND_SOC_TPLG_DAPM_POST		10
-+#define SND_SOC_TPLG_DAPM_AIF_IN	11
-+#define SND_SOC_TPLG_DAPM_AIF_OUT	12
-+#define SND_SOC_TPLG_DAPM_DAI_IN	13
-+#define SND_SOC_TPLG_DAPM_DAI_OUT	14
-+#define SND_SOC_TPLG_DAPM_DAI_LINK	15
-+#define SND_SOC_TPLG_DAPM_BUFFER	16
-+#define SND_SOC_TPLG_DAPM_SCHEDULER	17
-+#define SND_SOC_TPLG_DAPM_EFFECT	18
-+#define SND_SOC_TPLG_DAPM_SIGGEN	19
-+#define SND_SOC_TPLG_DAPM_SRC		20
-+#define SND_SOC_TPLG_DAPM_ASRC		21
-+#define SND_SOC_TPLG_DAPM_ENCODER	22
-+#define SND_SOC_TPLG_DAPM_DECODER	23
-+#define SND_SOC_TPLG_DAPM_LAST		SND_SOC_TPLG_DAPM_DECODER
-+
-+/* Header magic number and string sizes */
-+#define SND_SOC_TPLG_MAGIC		0x41536F43 /* ASoC */
-+
-+/* string sizes */
-+#define SND_SOC_TPLG_NUM_TEXTS		16
-+
-+/* ABI version */
-+#define SND_SOC_TPLG_ABI_VERSION	0x5	/* current version */
-+#define SND_SOC_TPLG_ABI_VERSION_MIN	0x4	/* oldest version supported */
-+
-+/* Max size of TLV data */
-+#define SND_SOC_TPLG_TLV_SIZE		32
-+
-+/*
-+ * File and Block header data types.
-+ * Add new generic and vendor types to end of list.
-+ * Generic types are handled by the core whilst vendors types are passed
-+ * to the component drivers for handling.
-+ */
-+#define SND_SOC_TPLG_TYPE_MIXER		1
-+#define SND_SOC_TPLG_TYPE_BYTES		2
-+#define SND_SOC_TPLG_TYPE_ENUM		3
-+#define SND_SOC_TPLG_TYPE_DAPM_GRAPH	4
-+#define SND_SOC_TPLG_TYPE_DAPM_WIDGET	5
-+#define SND_SOC_TPLG_TYPE_DAI_LINK	6
-+#define SND_SOC_TPLG_TYPE_PCM		7
-+#define SND_SOC_TPLG_TYPE_MANIFEST	8
-+#define SND_SOC_TPLG_TYPE_CODEC_LINK	9
-+#define SND_SOC_TPLG_TYPE_BACKEND_LINK	10
-+#define SND_SOC_TPLG_TYPE_PDATA		11
-+#define SND_SOC_TPLG_TYPE_DAI		12
-+#define SND_SOC_TPLG_TYPE_MAX		SND_SOC_TPLG_TYPE_DAI
-+
-+/* vendor block IDs - please add new vendor types to end */
-+#define SND_SOC_TPLG_TYPE_VENDOR_FW	1000
-+#define SND_SOC_TPLG_TYPE_VENDOR_CONFIG	1001
-+#define SND_SOC_TPLG_TYPE_VENDOR_COEFF	1002
-+#define SND_SOC_TPLG_TYPEVENDOR_CODEC	1003
-+
-+#define SND_SOC_TPLG_STREAM_PLAYBACK	0
-+#define SND_SOC_TPLG_STREAM_CAPTURE	1
-+
-+/* vendor tuple types */
-+#define SND_SOC_TPLG_TUPLE_TYPE_UUID	0
-+#define SND_SOC_TPLG_TUPLE_TYPE_STRING	1
-+#define SND_SOC_TPLG_TUPLE_TYPE_BOOL	2
-+#define SND_SOC_TPLG_TUPLE_TYPE_BYTE	3
-+#define SND_SOC_TPLG_TUPLE_TYPE_WORD	4
-+#define SND_SOC_TPLG_TUPLE_TYPE_SHORT	5
-+
-+/* DAI flags */
-+#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES         (1 << 0)
-+#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS      (1 << 1)
-+#define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS    (1 << 2)
-+
-+/* DAI clock gating */
-+#define SND_SOC_TPLG_DAI_CLK_GATE_UNDEFINED	0
-+#define SND_SOC_TPLG_DAI_CLK_GATE_GATED	1
-+#define SND_SOC_TPLG_DAI_CLK_GATE_CONT		2
-+
-+/* DAI mclk_direction */
-+#define SND_SOC_TPLG_MCLK_CO            0 /* for codec, mclk is output */
-+#define SND_SOC_TPLG_MCLK_CI            1 /* for codec, mclk is input */
-+
-+/* DAI physical PCM data formats.
-+ * Add new formats to the end of the list.
-+ */
-+#define SND_SOC_DAI_FORMAT_I2S          1 /* I2S mode */
-+#define SND_SOC_DAI_FORMAT_RIGHT_J      2 /* Right Justified mode */
-+#define SND_SOC_DAI_FORMAT_LEFT_J       3 /* Left Justified mode */
-+#define SND_SOC_DAI_FORMAT_DSP_A        4 /* L data MSB after FRM LRC */
-+#define SND_SOC_DAI_FORMAT_DSP_B        5 /* L data MSB during FRM LRC */
-+#define SND_SOC_DAI_FORMAT_AC97         6 /* AC97 */
-+#define SND_SOC_DAI_FORMAT_PDM          7 /* Pulse density modulation */
-+
-+/* left and right justified also known as MSB and LSB respectively */
-+#define SND_SOC_DAI_FORMAT_MSB          SND_SOC_DAI_FORMAT_LEFT_J
-+#define SND_SOC_DAI_FORMAT_LSB          SND_SOC_DAI_FORMAT_RIGHT_J
-+
-+/* DAI link flags */
-+#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES         (1 << 0)
-+#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS      (1 << 1)
-+#define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS    (1 << 2)
-+#define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP            (1 << 3)
-+
-+/* DAI topology BCLK parameter
-+ * For the backwards capability, by default codec is bclk master
-+ */
-+#define SND_SOC_TPLG_BCLK_CM         0 /* codec is bclk master */
-+#define SND_SOC_TPLG_BCLK_CS         1 /* codec is bclk slave */
-+
-+/* DAI topology FSYNC parameter
-+ * For the backwards capability, by default codec is fsync master
-+ */
-+#define SND_SOC_TPLG_FSYNC_CM         0 /* codec is fsync master */
-+#define SND_SOC_TPLG_FSYNC_CS         1 /* codec is fsync slave */
-+
-+/*
-+ * Block Header.
-+ * This header precedes all object and object arrays below.
-+ */
-+struct snd_soc_tplg_hdr {
-+	__le32 magic;		/* magic number */
-+	__le32 abi;		/* ABI version */
-+	__le32 version;		/* optional vendor specific version details */
-+	__le32 type;		/* SND_SOC_TPLG_TYPE_ */
-+	__le32 size;		/* size of this structure */
-+	__le32 vendor_type;	/* optional vendor specific type info */
-+	__le32 payload_size;	/* data bytes, excluding this header */
-+	__le32 index;		/* identifier for block */
-+	__le32 count;		/* number of elements in block */
-+} __attribute__((packed));
-+
-+/* vendor tuple for uuid */
-+struct snd_soc_tplg_vendor_uuid_elem {
-+	__le32 token;
-+	char uuid[16];
-+} __attribute__((packed));
-+
-+/* vendor tuple for a bool/byte/short/word value */
-+struct snd_soc_tplg_vendor_value_elem {
-+	__le32 token;
-+	__le32 value;
-+} __attribute__((packed));
-+
-+/* vendor tuple for string */
-+struct snd_soc_tplg_vendor_string_elem {
-+	__le32 token;
-+	char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+} __attribute__((packed));
-+
-+struct snd_soc_tplg_vendor_array {
-+	__le32 size;	/* size in bytes of the array, including all elements */
-+	__le32 type;	/* SND_SOC_TPLG_TUPLE_TYPE_ */
-+	__le32 num_elems;	/* number of elements in array */
-+	union {
-+		struct snd_soc_tplg_vendor_uuid_elem uuid[0];
-+		struct snd_soc_tplg_vendor_value_elem value[0];
-+		struct snd_soc_tplg_vendor_string_elem string[0];
-+	};
-+} __attribute__((packed));
-+
-+/*
-+ * Private data.
-+ * All topology objects may have private data that can be used by the driver or
-+ * firmware. Core will ignore this data.
-+ */
-+struct snd_soc_tplg_private {
-+	__le32 size;	/* in bytes of private data */
-+	union {
-+		char data[0];
-+		struct snd_soc_tplg_vendor_array array[0];
-+	};
-+} __attribute__((packed));
-+
-+/*
-+ * Kcontrol TLV data.
-+ */
-+struct snd_soc_tplg_tlv_dbscale {
-+	__le32 min;
-+	__le32 step;
-+	__le32 mute;
-+} __attribute__((packed));
-+
-+struct snd_soc_tplg_ctl_tlv {
-+	__le32 size;	/* in bytes of this structure */
-+	__le32 type;	/* SNDRV_CTL_TLVT_*, type of TLV */
-+	union {
-+		__le32 data[SND_SOC_TPLG_TLV_SIZE];
-+		struct snd_soc_tplg_tlv_dbscale scale;
-+	};
-+} __attribute__((packed));
-+
-+/*
-+ * Kcontrol channel data
-+ */
-+struct snd_soc_tplg_channel {
-+	__le32 size;	/* in bytes of this structure */
-+	__le32 reg;
-+	__le32 shift;
-+	__le32 id;	/* ID maps to Left, Right, LFE etc */
-+} __attribute__((packed));
-+
-+/*
-+ * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops
-+ * Kcontrol ops need get/put/info.
-+ * Bytes ext ops need get/put.
-+ */
-+struct snd_soc_tplg_io_ops {
-+	__le32 get;
-+	__le32 put;
-+	__le32 info;
-+} __attribute__((packed));
-+
-+/*
-+ * kcontrol header
-+ */
-+struct snd_soc_tplg_ctl_hdr {
-+	__le32 size;	/* in bytes of this structure */
-+	__le32 type;
-+	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	__le32 access;
-+	struct snd_soc_tplg_io_ops ops;
-+	struct snd_soc_tplg_ctl_tlv tlv;
-+} __attribute__((packed));
-+
-+/*
-+ * Stream Capabilities
-+ */
-+struct snd_soc_tplg_stream_caps {
-+	__le32 size;		/* in bytes of this structure */
-+	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	__le64 formats;	/* supported formats SNDRV_PCM_FMTBIT_* */
-+	__le32 rates;		/* supported rates SNDRV_PCM_RATE_* */
-+	__le32 rate_min;	/* min rate */
-+	__le32 rate_max;	/* max rate */
-+	__le32 channels_min;	/* min channels */
-+	__le32 channels_max;	/* max channels */
-+	__le32 periods_min;	/* min number of periods */
-+	__le32 periods_max;	/* max number of periods */
-+	__le32 period_size_min;	/* min period size bytes */
-+	__le32 period_size_max;	/* max period size bytes */
-+	__le32 buffer_size_min;	/* min buffer size bytes */
-+	__le32 buffer_size_max;	/* max buffer size bytes */
-+	__le32 sig_bits;        /* number of bits of content */
-+} __attribute__((packed));
-+
-+/*
-+ * FE or BE Stream configuration supported by SW/FW
-+ */
-+struct snd_soc_tplg_stream {
-+	__le32 size;		/* in bytes of this structure */
-+	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* Name of the stream */
-+	__le64 format;		/* SNDRV_PCM_FMTBIT_* */
-+	__le32 rate;		/* SNDRV_PCM_RATE_* */
-+	__le32 period_bytes;	/* size of period in bytes */
-+	__le32 buffer_bytes;	/* size of buffer in bytes */
-+	__le32 channels;	/* channels */
-+} __attribute__((packed));
-+
-+
-+/*
-+ * Describes a physical link's runtime supported hardware config,
-+ * i.e. hardware audio formats.
-+ */
-+struct snd_soc_tplg_hw_config {
-+	__le32 size;            /* in bytes of this structure */
-+	__le32 id;		/* unique ID - - used to match */
-+	__le32 fmt;		/* SND_SOC_DAI_FORMAT_ format value */
-+	__u8 clock_gated;	/* SND_SOC_TPLG_DAI_CLK_GATE_ value */
-+	__u8 invert_bclk;	/* 1 for inverted BCLK, 0 for normal */
-+	__u8 invert_fsync;	/* 1 for inverted frame clock, 0 for normal */
-+	__u8 bclk_master;	/* SND_SOC_TPLG_BCLK_ value */
-+	__u8 fsync_master;	/* SND_SOC_TPLG_FSYNC_ value */
-+	__u8 mclk_direction;    /* SND_SOC_TPLG_MCLK_ value */
-+	__le16 reserved;	/* for 32bit alignment */
-+	__le32 mclk_rate;	/* MCLK or SYSCLK freqency in Hz */
-+	__le32 bclk_rate;	/* BCLK freqency in Hz */
-+	__le32 fsync_rate;	/* frame clock in Hz */
-+	__le32 tdm_slots;	/* number of TDM slots in use */
-+	__le32 tdm_slot_width;	/* width in bits for each slot */
-+	__le32 tx_slots;	/* bit mask for active Tx slots */
-+	__le32 rx_slots;	/* bit mask for active Rx slots */
-+	__le32 tx_channels;	/* number of Tx channels */
-+	__le32 tx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */
-+	__le32 rx_channels;	/* number of Rx channels */
-+	__le32 rx_chanmap[SND_SOC_TPLG_MAX_CHAN]; /* array of slot number */
-+} __attribute__((packed));
-+
-+/*
-+ * Manifest. List totals for each payload type. Not used in parsing, but will
-+ * be passed to the component driver before any other objects in order for any
-+ * global component resource allocations.
-+ *
-+ * File block representation for manifest :-
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_hdr           |  1 |
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_manifest      |  1 |
-+ * +-----------------------------------+----+
-+ */
-+struct snd_soc_tplg_manifest {
-+	__le32 size;		/* in bytes of this structure */
-+	__le32 control_elems;	/* number of control elements */
-+	__le32 widget_elems;	/* number of widget elements */
-+	__le32 graph_elems;	/* number of graph elements */
-+	__le32 pcm_elems;	/* number of PCM elements */
-+	__le32 dai_link_elems;	/* number of DAI link elements */
-+	__le32 dai_elems;	/* number of physical DAI elements */
-+	__le32 reserved[20];	/* reserved for new ABI element types */
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+/*
-+ * Mixer kcontrol.
-+ *
-+ * File block representation for mixer kcontrol :-
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_hdr           |  1 |
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_mixer_control |  N |
-+ * +-----------------------------------+----+
-+ */
-+struct snd_soc_tplg_mixer_control {
-+	struct snd_soc_tplg_ctl_hdr hdr;
-+	__le32 size;	/* in bytes of this structure */
-+	__le32 min;
-+	__le32 max;
-+	__le32 platform_max;
-+	__le32 invert;
-+	__le32 num_channels;
-+	struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN];
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+/*
-+ * Enumerated kcontrol
-+ *
-+ * File block representation for enum kcontrol :-
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_hdr           |  1 |
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_enum_control  |  N |
-+ * +-----------------------------------+----+
-+ */
-+struct snd_soc_tplg_enum_control {
-+	struct snd_soc_tplg_ctl_hdr hdr;
-+	__le32 size;	/* in bytes of this structure */
-+	__le32 num_channels;
-+	struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN];
-+	__le32 items;
-+	__le32 mask;
-+	__le32 count;
-+	char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	__le32 values[SND_SOC_TPLG_NUM_TEXTS * SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4];
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+/*
-+ * Bytes kcontrol
-+ *
-+ * File block representation for bytes kcontrol :-
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_hdr           |  1 |
-+ * +-----------------------------------+----+
-+ * | struct snd_soc_tplg_bytes_control |  N |
-+ * +-----------------------------------+----+
-+ */
-+struct snd_soc_tplg_bytes_control {
-+	struct snd_soc_tplg_ctl_hdr hdr;
-+	__le32 size;	/* in bytes of this structure */
-+	__le32 max;
-+	__le32 mask;
-+	__le32 base;
-+	__le32 num_regs;
-+	struct snd_soc_tplg_io_ops ext_ops;
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+/*
-+ * DAPM Graph Element
-+ *
-+ * File block representation for DAPM graph elements :-
-+ * +-------------------------------------+----+
-+ * | struct snd_soc_tplg_hdr             |  1 |
-+ * +-------------------------------------+----+
-+ * | struct snd_soc_tplg_dapm_graph_elem |  N |
-+ * +-------------------------------------+----+
-+ */
-+struct snd_soc_tplg_dapm_graph_elem {
-+	char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+} __attribute__((packed));
-+
-+/*
-+ * DAPM Widget.
-+ *
-+ * File block representation for DAPM widget :-
-+ * +-------------------------------------+-----+
-+ * | struct snd_soc_tplg_hdr             |  1  |
-+ * +-------------------------------------+-----+
-+ * | struct snd_soc_tplg_dapm_widget     |  N  |
-+ * +-------------------------------------+-----+
-+ * |   struct snd_soc_tplg_enum_control  | 0|1 |
-+ * |   struct snd_soc_tplg_mixer_control | 0|N |
-+ * +-------------------------------------+-----+
-+ *
-+ * Optional enum or mixer control can be appended to the end of each widget
-+ * in the block.
-+ */
-+struct snd_soc_tplg_dapm_widget {
-+	__le32 size;		/* in bytes of this structure */
-+	__le32 id;		/* SND_SOC_DAPM_CTL */
-+	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+
-+	__le32 reg;		/* negative reg = no direct dapm */
-+	__le32 shift;		/* bits to shift */
-+	__le32 mask;		/* non-shifted mask */
-+	__le32 subseq;		/* sort within widget type */
-+	__le32 invert;		/* invert the power bit */
-+	__le32 ignore_suspend;	/* kept enabled over suspend */
-+	__le16 event_flags;
-+	__le16 event_type;
-+	__le32 num_kcontrols;
-+	struct snd_soc_tplg_private priv;
-+	/*
-+	 * kcontrols that relate to this widget
-+	 * follow here after widget private data
-+	 */
-+} __attribute__((packed));
-+
-+
-+/*
-+ * Describes SW/FW specific features of PCM (FE DAI & DAI link).
-+ *
-+ * File block representation for PCM :-
-+ * +-----------------------------------+-----+
-+ * | struct snd_soc_tplg_hdr           |  1  |
-+ * +-----------------------------------+-----+
-+ * | struct snd_soc_tplg_pcm           |  N  |
-+ * +-----------------------------------+-----+
-+ */
-+struct snd_soc_tplg_pcm {
-+	__le32 size;		/* in bytes of this structure */
-+	char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	__le32 pcm_id;		/* unique ID - used to match with DAI link */
-+	__le32 dai_id;		/* unique ID - used to match */
-+	__le32 playback;	/* supports playback mode */
-+	__le32 capture;		/* supports capture mode */
-+	__le32 compress;	/* 1 = compressed; 0 = PCM */
-+	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */
-+	__le32 num_streams;	/* number of streams */
-+	struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */
-+	__le32 flag_mask;       /* bitmask of flags to configure */
-+	__le32 flags;           /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+
-+/*
-+ * Describes the physical link runtime supported configs or params
-+ *
-+ * File block representation for physical link config :-
-+ * +-----------------------------------+-----+
-+ * | struct snd_soc_tplg_hdr           |  1  |
-+ * +-----------------------------------+-----+
-+ * | struct snd_soc_tplg_link_config   |  N  |
-+ * +-----------------------------------+-----+
-+ */
-+struct snd_soc_tplg_link_config {
-+	__le32 size;            /* in bytes of this structure */
-+	__le32 id;              /* unique ID - used to match */
-+	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */
-+	char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* stream name - used to match */
-+	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */
-+	__le32 num_streams;     /* number of streams */
-+	struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; /* hw configs */
-+	__le32 num_hw_configs;         /* number of hw configs */
-+	__le32 default_hw_config_id;   /* default hw config ID for init */
-+	__le32 flag_mask;       /* bitmask of flags to configure */
-+	__le32 flags;           /* SND_SOC_TPLG_LNK_FLGBIT_* flag value */
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+/*
-+ * Describes SW/FW specific features of physical DAI.
-+ * It can be used to configure backend DAIs for DPCM.
-+ *
-+ * File block representation for physical DAI :-
-+ * +-----------------------------------+-----+
-+ * | struct snd_soc_tplg_hdr           |  1  |
-+ * +-----------------------------------+-----+
-+ * | struct snd_soc_tplg_dai           |  N  |
-+ * +-----------------------------------+-----+
-+ */
-+struct snd_soc_tplg_dai {
-+	__le32 size;            /* in bytes of this structure */
-+	char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* name - used to match */
-+	__le32 dai_id;          /* unique ID - used to match */
-+	__le32 playback;        /* supports playback mode */
-+	__le32 capture;         /* supports capture mode */
-+	struct snd_soc_tplg_stream_caps caps[2]; /* playback and capture for DAI */
-+	__le32 flag_mask;       /* bitmask of flags to configure */
-+	__le32 flags;           /* SND_SOC_TPLG_DAI_FLGBIT_* */
-+	struct snd_soc_tplg_private priv;
-+} __attribute__((packed));
-+
-+/*
-+ * Old version of ABI structs, supported for backward compatibility.
-+ */
-+
-+/* Manifest v4 */
-+struct snd_soc_tplg_manifest_v4 {
-+	__le32 size;		/* in bytes of this structure */
-+	__le32 control_elems;	/* number of control elements */
-+	__le32 widget_elems;	/* number of widget elements */
-+	__le32 graph_elems;	/* number of graph elements */
-+	__le32 pcm_elems;	/* number of PCM elements */
-+	__le32 dai_link_elems;	/* number of DAI link elements */
-+	struct snd_soc_tplg_private priv;
-+} __packed;
-+
-+/* Stream Capabilities v4 */
-+struct snd_soc_tplg_stream_caps_v4 {
-+	__le32 size;		/* in bytes of this structure */
-+	char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	__le64 formats;	/* supported formats SNDRV_PCM_FMTBIT_* */
-+	__le32 rates;		/* supported rates SNDRV_PCM_RATE_* */
-+	__le32 rate_min;	/* min rate */
-+	__le32 rate_max;	/* max rate */
-+	__le32 channels_min;	/* min channels */
-+	__le32 channels_max;	/* max channels */
-+	__le32 periods_min;	/* min number of periods */
-+	__le32 periods_max;	/* max number of periods */
-+	__le32 period_size_min;	/* min period size bytes */
-+	__le32 period_size_max;	/* max period size bytes */
-+	__le32 buffer_size_min;	/* min buffer size bytes */
-+	__le32 buffer_size_max;	/* max buffer size bytes */
-+} __packed;
-+
-+/* PCM v4 */
-+struct snd_soc_tplg_pcm_v4 {
-+	__le32 size;		/* in bytes of this structure */
-+	char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
-+	__le32 pcm_id;		/* unique ID - used to match with DAI link */
-+	__le32 dai_id;		/* unique ID - used to match */
-+	__le32 playback;	/* supports playback mode */
-+	__le32 capture;		/* supports capture mode */
-+	__le32 compress;	/* 1 = compressed; 0 = PCM */
-+	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* for DAI link */
-+	__le32 num_streams;	/* number of streams */
-+	struct snd_soc_tplg_stream_caps_v4 caps[2]; /* playback and capture for DAI */
-+} __packed;
-+
-+/* Physical link config v4 */
-+struct snd_soc_tplg_link_config_v4 {
-+	__le32 size;            /* in bytes of this structure */
-+	__le32 id;              /* unique ID - used to match */
-+	struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; /* supported configs playback and captrure */
-+	__le32 num_streams;     /* number of streams */
-+} __packed;
-+
-+#endif
-diff --git a/include/sound/uapi/asound.h b/include/sound/uapi/asound.h
-new file mode 100644
-index 00000000..df1153ce
---- /dev/null
-+++ b/include/sound/uapi/asound.h
-@@ -0,0 +1,1038 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+/*
-+ *  Advanced Linux Sound Architecture - ALSA - Driver
-+ *  Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>,
-+ *                             Abramo Bagnara <abramo@alsa-project.org>
-+ *
-+ *
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-+ *
-+ */
-+
-+#ifndef _UAPI__SOUND_ASOUND_H
-+#define _UAPI__SOUND_ASOUND_H
-+
-+#if defined(__KERNEL__) || defined(__linux__)
-+#include <linux/types.h>
-+#else
-+#include <sys/ioctl.h>
-+#endif
-+
-+#ifndef __KERNEL__
-+#include <stdlib.h>
-+#include <time.h>
-+#endif
-+
-+/*
-+ *  protocol version
-+ */
-+
-+#define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)|((minor)<<8)|(subminor))
-+#define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff)
-+#define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff)
-+#define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff)
-+#define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \
-+	(SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) || \
-+	 (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \
-+	   SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion)))
-+
-+/****************************************************************************
-+ *                                                                          *
-+ *        Digital audio interface					    *
-+ *                                                                          *
-+ ****************************************************************************/
-+
-+struct snd_aes_iec958 {
-+	unsigned char status[24];	/* AES/IEC958 channel status bits */
-+	unsigned char subcode[147];	/* AES/IEC958 subcode bits */
-+	unsigned char pad;		/* nothing */
-+	unsigned char dig_subframe[4];	/* AES/IEC958 subframe bits */
-+};
-+
-+/****************************************************************************
-+ *                                                                          *
-+ *        CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort		    *
-+ *                                                                          *
-+ ****************************************************************************/
-+
-+struct snd_cea_861_aud_if {
-+	unsigned char db1_ct_cc; /* coding type and channel count */
-+	unsigned char db2_sf_ss; /* sample frequency and size */
-+	unsigned char db3; /* not used, all zeros */
-+	unsigned char db4_ca; /* channel allocation code */
-+	unsigned char db5_dminh_lsv; /* downmix inhibit & level-shit values */
-+};
-+
-+/****************************************************************************
-+ *                                                                          *
-+ *      Section for driver hardware dependent interface - /dev/snd/hw?      *
-+ *                                                                          *
-+ ****************************************************************************/
-+
-+#define SNDRV_HWDEP_VERSION		SNDRV_PROTOCOL_VERSION(1, 0, 1)
-+
-+enum {
-+	SNDRV_HWDEP_IFACE_OPL2 = 0,
-+	SNDRV_HWDEP_IFACE_OPL3,
-+	SNDRV_HWDEP_IFACE_OPL4,
-+	SNDRV_HWDEP_IFACE_SB16CSP,	/* Creative Signal Processor */
-+	SNDRV_HWDEP_IFACE_EMU10K1,	/* FX8010 processor in EMU10K1 chip */
-+	SNDRV_HWDEP_IFACE_YSS225,	/* Yamaha FX processor */
-+	SNDRV_HWDEP_IFACE_ICS2115,	/* Wavetable synth */
-+	SNDRV_HWDEP_IFACE_SSCAPE,	/* Ensoniq SoundScape ISA card (MC68EC000) */
-+	SNDRV_HWDEP_IFACE_VX,		/* Digigram VX cards */
-+	SNDRV_HWDEP_IFACE_MIXART,	/* Digigram miXart cards */
-+	SNDRV_HWDEP_IFACE_USX2Y,	/* Tascam US122, US224 & US428 usb */
-+	SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, /* EmuX wavetable */
-+	SNDRV_HWDEP_IFACE_BLUETOOTH,	/* Bluetooth audio */
-+	SNDRV_HWDEP_IFACE_USX2Y_PCM,	/* Tascam US122, US224 & US428 rawusb pcm */
-+	SNDRV_HWDEP_IFACE_PCXHR,	/* Digigram PCXHR */
-+	SNDRV_HWDEP_IFACE_SB_RC,	/* SB Extigy/Audigy2NX remote control */
-+	SNDRV_HWDEP_IFACE_HDA,		/* HD-audio */
-+	SNDRV_HWDEP_IFACE_USB_STREAM,	/* direct access to usb stream */
-+	SNDRV_HWDEP_IFACE_FW_DICE,	/* TC DICE FireWire device */
-+	SNDRV_HWDEP_IFACE_FW_FIREWORKS,	/* Echo Audio Fireworks based device */
-+	SNDRV_HWDEP_IFACE_FW_BEBOB,	/* BridgeCo BeBoB based device */
-+	SNDRV_HWDEP_IFACE_FW_OXFW,	/* Oxford OXFW970/971 based device */
-+	SNDRV_HWDEP_IFACE_FW_DIGI00X,	/* Digidesign Digi 002/003 family */
-+	SNDRV_HWDEP_IFACE_FW_TASCAM,	/* TASCAM FireWire series */
-+	SNDRV_HWDEP_IFACE_LINE6,	/* Line6 USB processors */
-+	SNDRV_HWDEP_IFACE_FW_MOTU,	/* MOTU FireWire series */
-+	SNDRV_HWDEP_IFACE_FW_FIREFACE,	/* RME Fireface series */
-+
-+	/* Don't forget to change the following: */
-+	SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_FIREFACE
-+};
-+
-+struct snd_hwdep_info {
-+	unsigned int device;		/* WR: device number */
-+	int card;			/* R: card number */
-+	unsigned char id[64];		/* ID (user selectable) */
-+	unsigned char name[80];		/* hwdep name */
-+	int iface;			/* hwdep interface */
-+	unsigned char reserved[64];	/* reserved for future */
-+};
-+
-+/* generic DSP loader */
-+struct snd_hwdep_dsp_status {
-+	unsigned int version;		/* R: driver-specific version */
-+	unsigned char id[32];		/* R: driver-specific ID string */
-+	unsigned int num_dsps;		/* R: number of DSP images to transfer */
-+	unsigned int dsp_loaded;	/* R: bit flags indicating the loaded DSPs */
-+	unsigned int chip_ready;	/* R: 1 = initialization finished */
-+	unsigned char reserved[16];	/* reserved for future use */
-+};
-+
-+struct snd_hwdep_dsp_image {
-+	unsigned int index;		/* W: DSP index */
-+	unsigned char name[64];		/* W: ID (e.g. file name) */
-+	unsigned char __user *image;	/* W: binary image */
-+	size_t length;			/* W: size of image in bytes */
-+	unsigned long driver_data;	/* W: driver-specific data */
-+};
-+
-+#define SNDRV_HWDEP_IOCTL_PVERSION	_IOR ('H', 0x00, int)
-+#define SNDRV_HWDEP_IOCTL_INFO		_IOR ('H', 0x01, struct snd_hwdep_info)
-+#define SNDRV_HWDEP_IOCTL_DSP_STATUS	_IOR('H', 0x02, struct snd_hwdep_dsp_status)
-+#define SNDRV_HWDEP_IOCTL_DSP_LOAD	_IOW('H', 0x03, struct snd_hwdep_dsp_image)
-+
-+/*****************************************************************************
-+ *                                                                           *
-+ *             Digital Audio (PCM) interface - /dev/snd/pcm??                *
-+ *                                                                           *
-+ *****************************************************************************/
-+
-+#define SNDRV_PCM_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 14)
-+
-+typedef unsigned long snd_pcm_uframes_t;
-+typedef signed long snd_pcm_sframes_t;
-+
-+enum {
-+	SNDRV_PCM_CLASS_GENERIC = 0,	/* standard mono or stereo device */
-+	SNDRV_PCM_CLASS_MULTI,		/* multichannel device */
-+	SNDRV_PCM_CLASS_MODEM,		/* software modem class */
-+	SNDRV_PCM_CLASS_DIGITIZER,	/* digitizer class */
-+	/* Don't forget to change the following: */
-+	SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER,
-+};
-+
-+enum {
-+	SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, /* mono or stereo subdevices are mixed together */
-+	SNDRV_PCM_SUBCLASS_MULTI_MIX,	/* multichannel subdevices are mixed together */
-+	/* Don't forget to change the following: */
-+	SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX,
-+};
-+
-+enum {
-+	SNDRV_PCM_STREAM_PLAYBACK = 0,
-+	SNDRV_PCM_STREAM_CAPTURE,
-+	SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE,
-+};
-+
-+typedef int __bitwise snd_pcm_access_t;
-+#define	SNDRV_PCM_ACCESS_MMAP_INTERLEAVED	((__force snd_pcm_access_t) 0) /* interleaved mmap */
-+#define	SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED	((__force snd_pcm_access_t) 1) /* noninterleaved mmap */
-+#define	SNDRV_PCM_ACCESS_MMAP_COMPLEX		((__force snd_pcm_access_t) 2) /* complex mmap */
-+#define	SNDRV_PCM_ACCESS_RW_INTERLEAVED		((__force snd_pcm_access_t) 3) /* readi/writei */
-+#define	SNDRV_PCM_ACCESS_RW_NONINTERLEAVED	((__force snd_pcm_access_t) 4) /* readn/writen */
-+#define	SNDRV_PCM_ACCESS_LAST		SNDRV_PCM_ACCESS_RW_NONINTERLEAVED
-+
-+typedef int __bitwise snd_pcm_format_t;
-+#define	SNDRV_PCM_FORMAT_S8	((__force snd_pcm_format_t) 0)
-+#define	SNDRV_PCM_FORMAT_U8	((__force snd_pcm_format_t) 1)
-+#define	SNDRV_PCM_FORMAT_S16_LE	((__force snd_pcm_format_t) 2)
-+#define	SNDRV_PCM_FORMAT_S16_BE	((__force snd_pcm_format_t) 3)
-+#define	SNDRV_PCM_FORMAT_U16_LE	((__force snd_pcm_format_t) 4)
-+#define	SNDRV_PCM_FORMAT_U16_BE	((__force snd_pcm_format_t) 5)
-+#define	SNDRV_PCM_FORMAT_S24_LE	((__force snd_pcm_format_t) 6) /* low three bytes */
-+#define	SNDRV_PCM_FORMAT_S24_BE	((__force snd_pcm_format_t) 7) /* low three bytes */
-+#define	SNDRV_PCM_FORMAT_U24_LE	((__force snd_pcm_format_t) 8) /* low three bytes */
-+#define	SNDRV_PCM_FORMAT_U24_BE	((__force snd_pcm_format_t) 9) /* low three bytes */
-+#define	SNDRV_PCM_FORMAT_S32_LE	((__force snd_pcm_format_t) 10)
-+#define	SNDRV_PCM_FORMAT_S32_BE	((__force snd_pcm_format_t) 11)
-+#define	SNDRV_PCM_FORMAT_U32_LE	((__force snd_pcm_format_t) 12)
-+#define	SNDRV_PCM_FORMAT_U32_BE	((__force snd_pcm_format_t) 13)
-+#define	SNDRV_PCM_FORMAT_FLOAT_LE	((__force snd_pcm_format_t) 14) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
-+#define	SNDRV_PCM_FORMAT_FLOAT_BE	((__force snd_pcm_format_t) 15) /* 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 */
-+#define	SNDRV_PCM_FORMAT_FLOAT64_LE	((__force snd_pcm_format_t) 16) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
-+#define	SNDRV_PCM_FORMAT_FLOAT64_BE	((__force snd_pcm_format_t) 17) /* 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 */
-+#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((__force snd_pcm_format_t) 18) /* IEC-958 subframe, Little Endian */
-+#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((__force snd_pcm_format_t) 19) /* IEC-958 subframe, Big Endian */
-+#define	SNDRV_PCM_FORMAT_MU_LAW		((__force snd_pcm_format_t) 20)
-+#define	SNDRV_PCM_FORMAT_A_LAW		((__force snd_pcm_format_t) 21)
-+#define	SNDRV_PCM_FORMAT_IMA_ADPCM	((__force snd_pcm_format_t) 22)
-+#define	SNDRV_PCM_FORMAT_MPEG		((__force snd_pcm_format_t) 23)
-+#define	SNDRV_PCM_FORMAT_GSM		((__force snd_pcm_format_t) 24)
-+#define	SNDRV_PCM_FORMAT_S20_LE	((__force snd_pcm_format_t) 25) /* in four bytes, LSB justified */
-+#define	SNDRV_PCM_FORMAT_S20_BE	((__force snd_pcm_format_t) 26) /* in four bytes, LSB justified */
-+#define	SNDRV_PCM_FORMAT_U20_LE	((__force snd_pcm_format_t) 27) /* in four bytes, LSB justified */
-+#define	SNDRV_PCM_FORMAT_U20_BE	((__force snd_pcm_format_t) 28) /* in four bytes, LSB justified */
-+/* gap in the numbering for a future standard linear format */
-+#define	SNDRV_PCM_FORMAT_SPECIAL	((__force snd_pcm_format_t) 31)
-+#define	SNDRV_PCM_FORMAT_S24_3LE	((__force snd_pcm_format_t) 32)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_S24_3BE	((__force snd_pcm_format_t) 33)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_U24_3LE	((__force snd_pcm_format_t) 34)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_U24_3BE	((__force snd_pcm_format_t) 35)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_S20_3LE	((__force snd_pcm_format_t) 36)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_S20_3BE	((__force snd_pcm_format_t) 37)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_U20_3LE	((__force snd_pcm_format_t) 38)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_U20_3BE	((__force snd_pcm_format_t) 39)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_S18_3LE	((__force snd_pcm_format_t) 40)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_S18_3BE	((__force snd_pcm_format_t) 41)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_U18_3LE	((__force snd_pcm_format_t) 42)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_U18_3BE	((__force snd_pcm_format_t) 43)	/* in three bytes */
-+#define	SNDRV_PCM_FORMAT_G723_24	((__force snd_pcm_format_t) 44) /* 8 samples in 3 bytes */
-+#define	SNDRV_PCM_FORMAT_G723_24_1B	((__force snd_pcm_format_t) 45) /* 1 sample in 1 byte */
-+#define	SNDRV_PCM_FORMAT_G723_40	((__force snd_pcm_format_t) 46) /* 8 Samples in 5 bytes */
-+#define	SNDRV_PCM_FORMAT_G723_40_1B	((__force snd_pcm_format_t) 47) /* 1 sample in 1 byte */
-+#define	SNDRV_PCM_FORMAT_DSD_U8		((__force snd_pcm_format_t) 48) /* DSD, 1-byte samples DSD (x8) */
-+#define	SNDRV_PCM_FORMAT_DSD_U16_LE	((__force snd_pcm_format_t) 49) /* DSD, 2-byte samples DSD (x16), little endian */
-+#define	SNDRV_PCM_FORMAT_DSD_U32_LE	((__force snd_pcm_format_t) 50) /* DSD, 4-byte samples DSD (x32), little endian */
-+#define	SNDRV_PCM_FORMAT_DSD_U16_BE	((__force snd_pcm_format_t) 51) /* DSD, 2-byte samples DSD (x16), big endian */
-+#define	SNDRV_PCM_FORMAT_DSD_U32_BE	((__force snd_pcm_format_t) 52) /* DSD, 4-byte samples DSD (x32), big endian */
-+#define	SNDRV_PCM_FORMAT_LAST		SNDRV_PCM_FORMAT_DSD_U32_BE
-+#define	SNDRV_PCM_FORMAT_FIRST		SNDRV_PCM_FORMAT_S8
-+
-+#ifdef SNDRV_LITTLE_ENDIAN
-+#define	SNDRV_PCM_FORMAT_S16		SNDRV_PCM_FORMAT_S16_LE
-+#define	SNDRV_PCM_FORMAT_U16		SNDRV_PCM_FORMAT_U16_LE
-+#define	SNDRV_PCM_FORMAT_S24		SNDRV_PCM_FORMAT_S24_LE
-+#define	SNDRV_PCM_FORMAT_U24		SNDRV_PCM_FORMAT_U24_LE
-+#define	SNDRV_PCM_FORMAT_S32		SNDRV_PCM_FORMAT_S32_LE
-+#define	SNDRV_PCM_FORMAT_U32		SNDRV_PCM_FORMAT_U32_LE
-+#define	SNDRV_PCM_FORMAT_FLOAT		SNDRV_PCM_FORMAT_FLOAT_LE
-+#define	SNDRV_PCM_FORMAT_FLOAT64	SNDRV_PCM_FORMAT_FLOAT64_LE
-+#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE
-+#define	SNDRV_PCM_FORMAT_S20		SNDRV_PCM_FORMAT_S20_LE
-+#define	SNDRV_PCM_FORMAT_U20		SNDRV_PCM_FORMAT_U20_LE
-+#endif
-+#ifdef SNDRV_BIG_ENDIAN
-+#define	SNDRV_PCM_FORMAT_S16		SNDRV_PCM_FORMAT_S16_BE
-+#define	SNDRV_PCM_FORMAT_U16		SNDRV_PCM_FORMAT_U16_BE
-+#define	SNDRV_PCM_FORMAT_S24		SNDRV_PCM_FORMAT_S24_BE
-+#define	SNDRV_PCM_FORMAT_U24		SNDRV_PCM_FORMAT_U24_BE
-+#define	SNDRV_PCM_FORMAT_S32		SNDRV_PCM_FORMAT_S32_BE
-+#define	SNDRV_PCM_FORMAT_U32		SNDRV_PCM_FORMAT_U32_BE
-+#define	SNDRV_PCM_FORMAT_FLOAT		SNDRV_PCM_FORMAT_FLOAT_BE
-+#define	SNDRV_PCM_FORMAT_FLOAT64	SNDRV_PCM_FORMAT_FLOAT64_BE
-+#define	SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE
-+#define	SNDRV_PCM_FORMAT_S20		SNDRV_PCM_FORMAT_S20_BE
-+#define	SNDRV_PCM_FORMAT_U20		SNDRV_PCM_FORMAT_U20_BE
-+#endif
-+
-+typedef int __bitwise snd_pcm_subformat_t;
-+#define	SNDRV_PCM_SUBFORMAT_STD		((__force snd_pcm_subformat_t) 0)
-+#define	SNDRV_PCM_SUBFORMAT_LAST	SNDRV_PCM_SUBFORMAT_STD
-+
-+#define SNDRV_PCM_INFO_MMAP		0x00000001	/* hardware supports mmap */
-+#define SNDRV_PCM_INFO_MMAP_VALID	0x00000002	/* period data are valid during transfer */
-+#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_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) */
-+#define SNDRV_PCM_INFO_BLOCK_TRANSFER	0x00010000	/* hardware transfer block of samples */
-+#define SNDRV_PCM_INFO_OVERRANGE	0x00020000	/* hardware supports ADC (capture) overrange detection */
-+#define SNDRV_PCM_INFO_RESUME		0x00040000	/* hardware supports stream resume after suspend */
-+#define SNDRV_PCM_INFO_PAUSE		0x00080000	/* pause ioctl is supported */
-+#define SNDRV_PCM_INFO_HALF_DUPLEX	0x00100000	/* only half duplex */
-+#define SNDRV_PCM_INFO_JOINT_DUPLEX	0x00200000	/* playback and capture stream are somewhat correlated */
-+#define SNDRV_PCM_INFO_SYNC_START	0x00400000	/* pcm support some kind of sync go */
-+#define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP	0x00800000	/* period wakeup can be disabled */
-+#define SNDRV_PCM_INFO_HAS_WALL_CLOCK   0x01000000      /* (Deprecated)has audio wall clock for audio/system time sync */
-+#define SNDRV_PCM_INFO_HAS_LINK_ATIME              0x01000000  /* report hardware link audio time, reset on startup */
-+#define SNDRV_PCM_INFO_HAS_LINK_ABSOLUTE_ATIME     0x02000000  /* report absolute hardware link audio time, not reset on startup */
-+#define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME    0x04000000  /* report estimated link audio time */
-+#define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000  /* report synchronized audio/system time */
-+
-+#define SNDRV_PCM_INFO_DRAIN_TRIGGER	0x40000000		/* internal kernel flag - trigger in drain */
-+#define SNDRV_PCM_INFO_FIFO_IN_FRAMES	0x80000000	/* internal kernel flag - FIFO size is in frames */
-+
-+
-+
-+typedef int __bitwise snd_pcm_state_t;
-+#define	SNDRV_PCM_STATE_OPEN		((__force snd_pcm_state_t) 0) /* stream is open */
-+#define	SNDRV_PCM_STATE_SETUP		((__force snd_pcm_state_t) 1) /* stream has a setup */
-+#define	SNDRV_PCM_STATE_PREPARED	((__force snd_pcm_state_t) 2) /* stream is ready to start */
-+#define	SNDRV_PCM_STATE_RUNNING		((__force snd_pcm_state_t) 3) /* stream is running */
-+#define	SNDRV_PCM_STATE_XRUN		((__force snd_pcm_state_t) 4) /* stream reached an xrun */
-+#define	SNDRV_PCM_STATE_DRAINING	((__force snd_pcm_state_t) 5) /* stream is draining */
-+#define	SNDRV_PCM_STATE_PAUSED		((__force snd_pcm_state_t) 6) /* stream is paused */
-+#define	SNDRV_PCM_STATE_SUSPENDED	((__force snd_pcm_state_t) 7) /* hardware is suspended */
-+#define	SNDRV_PCM_STATE_DISCONNECTED	((__force snd_pcm_state_t) 8) /* hardware is disconnected */
-+#define	SNDRV_PCM_STATE_LAST		SNDRV_PCM_STATE_DISCONNECTED
-+
-+enum {
-+	SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000,
-+	SNDRV_PCM_MMAP_OFFSET_STATUS = 0x80000000,
-+	SNDRV_PCM_MMAP_OFFSET_CONTROL = 0x81000000,
-+};
-+
-+union snd_pcm_sync_id {
-+	unsigned char id[16];
-+	unsigned short id16[8];
-+	unsigned int id32[4];
-+};
-+
-+struct snd_pcm_info {
-+	unsigned int device;		/* RO/WR (control): device number */
-+	unsigned int subdevice;		/* RO/WR (control): subdevice number */
-+	int stream;			/* RO/WR (control): stream direction */
-+	int card;			/* R: card number */
-+	unsigned char id[64];		/* ID (user selectable) */
-+	unsigned char name[80];		/* name of this device */
-+	unsigned char subname[32];	/* subdevice name */
-+	int dev_class;			/* SNDRV_PCM_CLASS_* */
-+	int dev_subclass;		/* SNDRV_PCM_SUBCLASS_* */
-+	unsigned int subdevices_count;
-+	unsigned int subdevices_avail;
-+	union snd_pcm_sync_id sync;	/* hardware synchronization ID */
-+	unsigned char reserved[64];	/* reserved for future... */
-+};
-+
-+typedef int snd_pcm_hw_param_t;
-+#define	SNDRV_PCM_HW_PARAM_ACCESS	0	/* Access type */
-+#define	SNDRV_PCM_HW_PARAM_FORMAT	1	/* Format */
-+#define	SNDRV_PCM_HW_PARAM_SUBFORMAT	2	/* Subformat */
-+#define	SNDRV_PCM_HW_PARAM_FIRST_MASK	SNDRV_PCM_HW_PARAM_ACCESS
-+#define	SNDRV_PCM_HW_PARAM_LAST_MASK	SNDRV_PCM_HW_PARAM_SUBFORMAT
-+
-+#define	SNDRV_PCM_HW_PARAM_SAMPLE_BITS	8	/* Bits per sample */
-+#define	SNDRV_PCM_HW_PARAM_FRAME_BITS	9	/* Bits per frame */
-+#define	SNDRV_PCM_HW_PARAM_CHANNELS	10	/* Channels */
-+#define	SNDRV_PCM_HW_PARAM_RATE		11	/* Approx rate */
-+#define	SNDRV_PCM_HW_PARAM_PERIOD_TIME	12	/* Approx distance between
-+						 * interrupts in us
-+						 */
-+#define	SNDRV_PCM_HW_PARAM_PERIOD_SIZE	13	/* Approx frames between
-+						 * interrupts
-+						 */
-+#define	SNDRV_PCM_HW_PARAM_PERIOD_BYTES	14	/* Approx bytes between
-+						 * interrupts
-+						 */
-+#define	SNDRV_PCM_HW_PARAM_PERIODS	15	/* Approx interrupts per
-+						 * buffer
-+						 */
-+#define	SNDRV_PCM_HW_PARAM_BUFFER_TIME	16	/* Approx duration of buffer
-+						 * in us
-+						 */
-+#define	SNDRV_PCM_HW_PARAM_BUFFER_SIZE	17	/* Size of buffer in frames */
-+#define	SNDRV_PCM_HW_PARAM_BUFFER_BYTES	18	/* Size of buffer in bytes */
-+#define	SNDRV_PCM_HW_PARAM_TICK_TIME	19	/* Approx tick duration in us */
-+#define	SNDRV_PCM_HW_PARAM_FIRST_INTERVAL	SNDRV_PCM_HW_PARAM_SAMPLE_BITS
-+#define	SNDRV_PCM_HW_PARAM_LAST_INTERVAL	SNDRV_PCM_HW_PARAM_TICK_TIME
-+
-+#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 */
-+
-+struct snd_interval {
-+	unsigned int min, max;
-+	unsigned int openmin:1,
-+		     openmax:1,
-+		     integer:1,
-+		     empty:1;
-+};
-+
-+#define SNDRV_MASK_MAX	256
-+
-+struct snd_mask {
-+	__u32 bits[(SNDRV_MASK_MAX+31)/32];
-+};
-+
-+struct snd_pcm_hw_params {
-+	unsigned int flags;
-+	struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK -
-+			       SNDRV_PCM_HW_PARAM_FIRST_MASK + 1];
-+	struct snd_mask mres[5];	/* reserved masks */
-+	struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL -
-+				        SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1];
-+	struct snd_interval ires[9];	/* reserved intervals */
-+	unsigned int rmask;		/* W: requested masks */
-+	unsigned int cmask;		/* R: changed masks */
-+	unsigned int info;		/* R: Info flags for returned setup */
-+	unsigned int msbits;		/* R: used most significant bits */
-+	unsigned int rate_num;		/* R: rate numerator */
-+	unsigned int rate_den;		/* R: rate denominator */
-+	snd_pcm_uframes_t fifo_size;	/* R: chip FIFO size in frames */
-+	unsigned char reserved[64];	/* reserved for future */
-+};
-+
-+enum {
-+	SNDRV_PCM_TSTAMP_NONE = 0,
-+	SNDRV_PCM_TSTAMP_ENABLE,
-+	SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE,
-+};
-+
-+struct snd_pcm_sw_params {
-+	int tstamp_mode;			/* timestamp mode */
-+	unsigned int period_step;
-+	unsigned int sleep_min;			/* min ticks to sleep */
-+	snd_pcm_uframes_t avail_min;		/* min avail frames for wakeup */
-+	snd_pcm_uframes_t xfer_align;		/* obsolete: xfer size need to be a multiple */
-+	snd_pcm_uframes_t start_threshold;	/* min hw_avail frames for automatic start */
-+	snd_pcm_uframes_t stop_threshold;	/* min avail frames for automatic stop */
-+	snd_pcm_uframes_t silence_threshold;	/* min distance from noise for silence filling */
-+	snd_pcm_uframes_t silence_size;		/* silence block size */
-+	snd_pcm_uframes_t boundary;		/* pointers wrap point */
-+	unsigned int proto;			/* protocol version */
-+	unsigned int tstamp_type;		/* timestamp type (req. proto >= 2.0.12) */
-+	unsigned char reserved[56];		/* reserved for future */
-+};
-+
-+struct snd_pcm_channel_info {
-+	unsigned int channel;
-+	__kernel_off_t offset;		/* mmap offset */
-+	unsigned int first;		/* offset to first sample in bits */
-+	unsigned int step;		/* samples distance in bits */
-+};
-+
-+enum {
-+	/*
-+	 *  first definition for backwards compatibility only,
-+	 *  maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else
-+	 */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0,
-+
-+	/* timestamp definitions */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1,           /* DMA time, reported as per hw_ptr */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2,	           /* link time reported by sample or wallclock counter, reset on startup */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3,	   /* link time reported by sample or wallclock counter, not reset on startup */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4,    /* link time estimated indirectly */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, /* link time synchronized with system time */
-+	SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED
-+};
-+
-+struct snd_pcm_status {
-+	snd_pcm_state_t state;		/* stream state */
-+	struct timespec trigger_tstamp;	/* time when stream was started/stopped/paused */
-+	struct timespec tstamp;		/* reference timestamp */
-+	snd_pcm_uframes_t appl_ptr;	/* appl ptr */
-+	snd_pcm_uframes_t hw_ptr;	/* hw ptr */
-+	snd_pcm_sframes_t delay;	/* current delay in frames */
-+	snd_pcm_uframes_t avail;	/* number of frames available */
-+	snd_pcm_uframes_t avail_max;	/* max frames available on hw since last status */
-+	snd_pcm_uframes_t overrange;	/* count of ADC (capture) overrange detections from last status */
-+	snd_pcm_state_t suspended_state; /* suspended stream state */
-+	__u32 audio_tstamp_data;	 /* needed for 64-bit alignment, used for configs/report to/from userspace */
-+	struct timespec audio_tstamp;	/* sample counter, wall clock, PHC or on-demand sync'ed */
-+	struct timespec driver_tstamp;	/* useful in case reference system tstamp is reported with delay */
-+	__u32 audio_tstamp_accuracy;	/* in ns units, only valid if indicated in audio_tstamp_data */
-+	unsigned char reserved[52-2*sizeof(struct timespec)]; /* must be filled with zero */
-+};
-+
-+struct snd_pcm_mmap_status {
-+	snd_pcm_state_t state;		/* RO: state - SNDRV_PCM_STATE_XXXX */
-+	int pad1;			/* Needed for 64 bit alignment */
-+	snd_pcm_uframes_t hw_ptr;	/* RO: hw ptr (0...boundary-1) */
-+	struct timespec tstamp;		/* Timestamp */
-+	snd_pcm_state_t suspended_state; /* RO: suspended stream state */
-+	struct timespec audio_tstamp;	/* from sample counter or wall clock */
-+};
-+
-+struct snd_pcm_mmap_control {
-+	snd_pcm_uframes_t appl_ptr;	/* RW: appl ptr (0...boundary-1) */
-+	snd_pcm_uframes_t avail_min;	/* RW: min available frames for wakeup */
-+};
-+
-+#define SNDRV_PCM_SYNC_PTR_HWSYNC	(1<<0)	/* execute hwsync */
-+#define SNDRV_PCM_SYNC_PTR_APPL		(1<<1)	/* get appl_ptr from driver (r/w op) */
-+#define SNDRV_PCM_SYNC_PTR_AVAIL_MIN	(1<<2)	/* get avail_min from driver */
-+
-+struct snd_pcm_sync_ptr {
-+	unsigned int flags;
-+	union {
-+		struct snd_pcm_mmap_status status;
-+		unsigned char reserved[64];
-+	} s;
-+	union {
-+		struct snd_pcm_mmap_control control;
-+		unsigned char reserved[64];
-+	} c;
-+};
-+
-+struct snd_xferi {
-+	snd_pcm_sframes_t result;
-+	void __user *buf;
-+	snd_pcm_uframes_t frames;
-+};
-+
-+struct snd_xfern {
-+	snd_pcm_sframes_t result;
-+	void __user * __user *bufs;
-+	snd_pcm_uframes_t frames;
-+};
-+
-+enum {
-+	SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0,	/* gettimeofday equivalent */
-+	SNDRV_PCM_TSTAMP_TYPE_MONOTONIC,	/* posix_clock_monotonic equivalent */
-+	SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW,    /* monotonic_raw (no NTP) */
-+	SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW,
-+};
-+
-+/* channel positions */
-+enum {
-+	SNDRV_CHMAP_UNKNOWN = 0,
-+	SNDRV_CHMAP_NA,		/* N/A, silent */
-+	SNDRV_CHMAP_MONO,	/* mono stream */
-+	/* this follows the alsa-lib mixer channel value + 3 */
-+	SNDRV_CHMAP_FL,		/* front left */
-+	SNDRV_CHMAP_FR,		/* front right */
-+	SNDRV_CHMAP_RL,		/* rear left */
-+	SNDRV_CHMAP_RR,		/* rear right */
-+	SNDRV_CHMAP_FC,		/* front center */
-+	SNDRV_CHMAP_LFE,	/* LFE */
-+	SNDRV_CHMAP_SL,		/* side left */
-+	SNDRV_CHMAP_SR,		/* side right */
-+	SNDRV_CHMAP_RC,		/* rear center */
-+	/* new definitions */
-+	SNDRV_CHMAP_FLC,	/* front left center */
-+	SNDRV_CHMAP_FRC,	/* front right center */
-+	SNDRV_CHMAP_RLC,	/* rear left center */
-+	SNDRV_CHMAP_RRC,	/* rear right center */
-+	SNDRV_CHMAP_FLW,	/* front left wide */
-+	SNDRV_CHMAP_FRW,	/* front right wide */
-+	SNDRV_CHMAP_FLH,	/* front left high */
-+	SNDRV_CHMAP_FCH,	/* front center high */
-+	SNDRV_CHMAP_FRH,	/* front right high */
-+	SNDRV_CHMAP_TC,		/* top center */
-+	SNDRV_CHMAP_TFL,	/* top front left */
-+	SNDRV_CHMAP_TFR,	/* top front right */
-+	SNDRV_CHMAP_TFC,	/* top front center */
-+	SNDRV_CHMAP_TRL,	/* top rear left */
-+	SNDRV_CHMAP_TRR,	/* top rear right */
-+	SNDRV_CHMAP_TRC,	/* top rear center */
-+	/* new definitions for UAC2 */
-+	SNDRV_CHMAP_TFLC,	/* top front left center */
-+	SNDRV_CHMAP_TFRC,	/* top front right center */
-+	SNDRV_CHMAP_TSL,	/* top side left */
-+	SNDRV_CHMAP_TSR,	/* top side right */
-+	SNDRV_CHMAP_LLFE,	/* left LFE */
-+	SNDRV_CHMAP_RLFE,	/* right LFE */
-+	SNDRV_CHMAP_BC,		/* bottom center */
-+	SNDRV_CHMAP_BLC,	/* bottom left center */
-+	SNDRV_CHMAP_BRC,	/* bottom right center */
-+	SNDRV_CHMAP_LAST = SNDRV_CHMAP_BRC,
-+};
-+
-+#define SNDRV_CHMAP_POSITION_MASK	0xffff
-+#define SNDRV_CHMAP_PHASE_INVERSE	(0x01 << 16)
-+#define SNDRV_CHMAP_DRIVER_SPEC		(0x02 << 16)
-+
-+#define SNDRV_PCM_IOCTL_PVERSION	_IOR('A', 0x00, int)
-+#define SNDRV_PCM_IOCTL_INFO		_IOR('A', 0x01, struct snd_pcm_info)
-+#define SNDRV_PCM_IOCTL_TSTAMP		_IOW('A', 0x02, int)
-+#define SNDRV_PCM_IOCTL_TTSTAMP		_IOW('A', 0x03, int)
-+#define SNDRV_PCM_IOCTL_USER_PVERSION	_IOW('A', 0x04, int)
-+#define SNDRV_PCM_IOCTL_HW_REFINE	_IOWR('A', 0x10, struct snd_pcm_hw_params)
-+#define SNDRV_PCM_IOCTL_HW_PARAMS	_IOWR('A', 0x11, struct snd_pcm_hw_params)
-+#define SNDRV_PCM_IOCTL_HW_FREE		_IO('A', 0x12)
-+#define SNDRV_PCM_IOCTL_SW_PARAMS	_IOWR('A', 0x13, struct snd_pcm_sw_params)
-+#define SNDRV_PCM_IOCTL_STATUS		_IOR('A', 0x20, struct snd_pcm_status)
-+#define SNDRV_PCM_IOCTL_DELAY		_IOR('A', 0x21, snd_pcm_sframes_t)
-+#define SNDRV_PCM_IOCTL_HWSYNC		_IO('A', 0x22)
-+#define SNDRV_PCM_IOCTL_SYNC_PTR	_IOWR('A', 0x23, struct snd_pcm_sync_ptr)
-+#define SNDRV_PCM_IOCTL_STATUS_EXT	_IOWR('A', 0x24, struct snd_pcm_status)
-+#define SNDRV_PCM_IOCTL_CHANNEL_INFO	_IOR('A', 0x32, struct snd_pcm_channel_info)
-+#define SNDRV_PCM_IOCTL_PREPARE		_IO('A', 0x40)
-+#define SNDRV_PCM_IOCTL_RESET		_IO('A', 0x41)
-+#define SNDRV_PCM_IOCTL_START		_IO('A', 0x42)
-+#define SNDRV_PCM_IOCTL_DROP		_IO('A', 0x43)
-+#define SNDRV_PCM_IOCTL_DRAIN		_IO('A', 0x44)
-+#define SNDRV_PCM_IOCTL_PAUSE		_IOW('A', 0x45, int)
-+#define SNDRV_PCM_IOCTL_REWIND		_IOW('A', 0x46, snd_pcm_uframes_t)
-+#define SNDRV_PCM_IOCTL_RESUME		_IO('A', 0x47)
-+#define SNDRV_PCM_IOCTL_XRUN		_IO('A', 0x48)
-+#define SNDRV_PCM_IOCTL_FORWARD		_IOW('A', 0x49, snd_pcm_uframes_t)
-+#define SNDRV_PCM_IOCTL_WRITEI_FRAMES	_IOW('A', 0x50, struct snd_xferi)
-+#define SNDRV_PCM_IOCTL_READI_FRAMES	_IOR('A', 0x51, struct snd_xferi)
-+#define SNDRV_PCM_IOCTL_WRITEN_FRAMES	_IOW('A', 0x52, struct snd_xfern)
-+#define SNDRV_PCM_IOCTL_READN_FRAMES	_IOR('A', 0x53, struct snd_xfern)
-+#define SNDRV_PCM_IOCTL_LINK		_IOW('A', 0x60, int)
-+#define SNDRV_PCM_IOCTL_UNLINK		_IO('A', 0x61)
-+
-+/*****************************************************************************
-+ *                                                                           *
-+ *                            MIDI v1.0 interface                            *
-+ *                                                                           *
-+ *****************************************************************************/
-+
-+/*
-+ *  Raw MIDI section - /dev/snd/midi??
-+ */
-+
-+#define SNDRV_RAWMIDI_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 0)
-+
-+enum {
-+	SNDRV_RAWMIDI_STREAM_OUTPUT = 0,
-+	SNDRV_RAWMIDI_STREAM_INPUT,
-+	SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT,
-+};
-+
-+#define SNDRV_RAWMIDI_INFO_OUTPUT		0x00000001
-+#define SNDRV_RAWMIDI_INFO_INPUT		0x00000002
-+#define SNDRV_RAWMIDI_INFO_DUPLEX		0x00000004
-+
-+struct snd_rawmidi_info {
-+	unsigned int device;		/* RO/WR (control): device number */
-+	unsigned int subdevice;		/* RO/WR (control): subdevice number */
-+	int stream;			/* WR: stream */
-+	int card;			/* R: card number */
-+	unsigned int flags;		/* SNDRV_RAWMIDI_INFO_XXXX */
-+	unsigned char id[64];		/* ID (user selectable) */
-+	unsigned char name[80];		/* name of device */
-+	unsigned char subname[32];	/* name of active or selected subdevice */
-+	unsigned int subdevices_count;
-+	unsigned int subdevices_avail;
-+	unsigned char reserved[64];	/* reserved for future use */
-+};
-+
-+struct snd_rawmidi_params {
-+	int stream;
-+	size_t buffer_size;		/* queue size in bytes */
-+	size_t avail_min;		/* minimum avail bytes for wakeup */
-+	unsigned int no_active_sensing: 1; /* do not send active sensing byte in close() */
-+	unsigned char reserved[16];	/* reserved for future use */
-+};
-+
-+struct snd_rawmidi_status {
-+	int stream;
-+	struct timespec tstamp;		/* Timestamp */
-+	size_t avail;			/* available bytes */
-+	size_t xruns;			/* count of overruns since last status (in bytes) */
-+	unsigned char reserved[16];	/* reserved for future use */
-+};
-+
-+#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_PARAMS	_IOWR('W', 0x10, struct snd_rawmidi_params)
-+#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)
-+
-+/*
-+ *  Timer section - /dev/snd/timer
-+ */
-+
-+#define SNDRV_TIMER_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 6)
-+
-+enum {
-+	SNDRV_TIMER_CLASS_NONE = -1,
-+	SNDRV_TIMER_CLASS_SLAVE = 0,
-+	SNDRV_TIMER_CLASS_GLOBAL,
-+	SNDRV_TIMER_CLASS_CARD,
-+	SNDRV_TIMER_CLASS_PCM,
-+	SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM,
-+};
-+
-+/* slave timer classes */
-+enum {
-+	SNDRV_TIMER_SCLASS_NONE = 0,
-+	SNDRV_TIMER_SCLASS_APPLICATION,
-+	SNDRV_TIMER_SCLASS_SEQUENCER,		/* alias */
-+	SNDRV_TIMER_SCLASS_OSS_SEQUENCER,	/* alias */
-+	SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER,
-+};
-+
-+/* global timers (device member) */
-+#define SNDRV_TIMER_GLOBAL_SYSTEM	0
-+#define SNDRV_TIMER_GLOBAL_RTC		1	/* unused */
-+#define SNDRV_TIMER_GLOBAL_HPET		2
-+#define SNDRV_TIMER_GLOBAL_HRTIMER	3
-+
-+/* info flags */
-+#define SNDRV_TIMER_FLG_SLAVE		(1<<0)	/* cannot be controlled */
-+
-+struct snd_timer_id {
-+	int dev_class;
-+	int dev_sclass;
-+	int card;
-+	int device;
-+	int subdevice;
-+};
-+
-+struct snd_timer_ginfo {
-+	struct snd_timer_id tid;	/* requested timer ID */
-+	unsigned int flags;		/* timer flags - SNDRV_TIMER_FLG_* */
-+	int card;			/* card number */
-+	unsigned char id[64];		/* timer identification */
-+	unsigned char name[80];		/* timer name */
-+	unsigned long reserved0;	/* reserved for future use */
-+	unsigned long resolution;	/* average period resolution in ns */
-+	unsigned long resolution_min;	/* minimal period resolution in ns */
-+	unsigned long resolution_max;	/* maximal period resolution in ns */
-+	unsigned int clients;		/* active timer clients */
-+	unsigned char reserved[32];
-+};
-+
-+struct snd_timer_gparams {
-+	struct snd_timer_id tid;	/* requested timer ID */
-+	unsigned long period_num;	/* requested precise period duration (in seconds) - numerator */
-+	unsigned long period_den;	/* requested precise period duration (in seconds) - denominator */
-+	unsigned char reserved[32];
-+};
-+
-+struct snd_timer_gstatus {
-+	struct snd_timer_id tid;	/* requested timer ID */
-+	unsigned long resolution;	/* current period resolution in ns */
-+	unsigned long resolution_num;	/* precise current period resolution (in seconds) - numerator */
-+	unsigned long resolution_den;	/* precise current period resolution (in seconds) - denominator */
-+	unsigned char reserved[32];
-+};
-+
-+struct snd_timer_select {
-+	struct snd_timer_id id;	/* bind to timer ID */
-+	unsigned char reserved[32];	/* reserved */
-+};
-+
-+struct snd_timer_info {
-+	unsigned int flags;		/* timer flags - SNDRV_TIMER_FLG_* */
-+	int card;			/* card number */
-+	unsigned char id[64];		/* timer identificator */
-+	unsigned char name[80];		/* timer name */
-+	unsigned long reserved0;	/* reserved for future use */
-+	unsigned long resolution;	/* average period resolution in ns */
-+	unsigned char reserved[64];	/* reserved */
-+};
-+
-+#define SNDRV_TIMER_PSFLG_AUTO		(1<<0)	/* auto start, otherwise one-shot */
-+#define SNDRV_TIMER_PSFLG_EXCLUSIVE	(1<<1)	/* exclusive use, precise start/stop/pause/continue */
-+#define SNDRV_TIMER_PSFLG_EARLY_EVENT	(1<<2)	/* write early event to the poll queue */
-+
-+struct snd_timer_params {
-+	unsigned int flags;		/* flags - SNDRV_TIMER_PSFLG_* */
-+	unsigned int ticks;		/* requested resolution in ticks */
-+	unsigned int queue_size;	/* total size of queue (32-1024) */
-+	unsigned int reserved0;		/* reserved, was: failure locations */
-+	unsigned int filter;		/* event filter (bitmask of SNDRV_TIMER_EVENT_*) */
-+	unsigned char reserved[60];	/* reserved */
-+};
-+
-+struct snd_timer_status {
-+	struct timespec tstamp;		/* Timestamp - last update */
-+	unsigned int resolution;	/* current period resolution in ns */
-+	unsigned int lost;		/* counter of master tick lost */
-+	unsigned int overrun;		/* count of read queue overruns */
-+	unsigned int queue;		/* used queue size */
-+	unsigned char reserved[64];	/* reserved */
-+};
-+
-+#define SNDRV_TIMER_IOCTL_PVERSION	_IOR('T', 0x00, int)
-+#define SNDRV_TIMER_IOCTL_NEXT_DEVICE	_IOWR('T', 0x01, struct snd_timer_id)
-+#define SNDRV_TIMER_IOCTL_TREAD		_IOW('T', 0x02, int)
-+#define SNDRV_TIMER_IOCTL_GINFO		_IOWR('T', 0x03, struct snd_timer_ginfo)
-+#define SNDRV_TIMER_IOCTL_GPARAMS	_IOW('T', 0x04, struct snd_timer_gparams)
-+#define SNDRV_TIMER_IOCTL_GSTATUS	_IOWR('T', 0x05, struct snd_timer_gstatus)
-+#define SNDRV_TIMER_IOCTL_SELECT	_IOW('T', 0x10, struct snd_timer_select)
-+#define SNDRV_TIMER_IOCTL_INFO		_IOR('T', 0x11, struct snd_timer_info)
-+#define SNDRV_TIMER_IOCTL_PARAMS	_IOW('T', 0x12, struct snd_timer_params)
-+#define SNDRV_TIMER_IOCTL_STATUS	_IOR('T', 0x14, struct snd_timer_status)
-+/* The following four ioctls are changed since 1.0.9 due to confliction */
-+#define SNDRV_TIMER_IOCTL_START		_IO('T', 0xa0)
-+#define SNDRV_TIMER_IOCTL_STOP		_IO('T', 0xa1)
-+#define SNDRV_TIMER_IOCTL_CONTINUE	_IO('T', 0xa2)
-+#define SNDRV_TIMER_IOCTL_PAUSE		_IO('T', 0xa3)
-+
-+struct snd_timer_read {
-+	unsigned int resolution;
-+	unsigned int ticks;
-+};
-+
-+enum {
-+	SNDRV_TIMER_EVENT_RESOLUTION = 0,	/* val = resolution in ns */
-+	SNDRV_TIMER_EVENT_TICK,			/* val = ticks */
-+	SNDRV_TIMER_EVENT_START,		/* val = resolution in ns */
-+	SNDRV_TIMER_EVENT_STOP,			/* val = 0 */
-+	SNDRV_TIMER_EVENT_CONTINUE,		/* val = resolution in ns */
-+	SNDRV_TIMER_EVENT_PAUSE,		/* val = 0 */
-+	SNDRV_TIMER_EVENT_EARLY,		/* val = 0, early event */
-+	SNDRV_TIMER_EVENT_SUSPEND,		/* val = 0 */
-+	SNDRV_TIMER_EVENT_RESUME,		/* val = resolution in ns */
-+	/* master timer events for slave timer instances */
-+	SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10,
-+	SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10,
-+	SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10,
-+	SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10,
-+	SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10,
-+	SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10,
-+};
-+
-+struct snd_timer_tread {
-+	int event;
-+	struct timespec tstamp;
-+	unsigned int val;
-+};
-+
-+/****************************************************************************
-+ *                                                                          *
-+ *        Section for driver control interface - /dev/snd/control?          *
-+ *                                                                          *
-+ ****************************************************************************/
-+
-+#define SNDRV_CTL_VERSION		SNDRV_PROTOCOL_VERSION(2, 0, 7)
-+
-+struct snd_ctl_card_info {
-+	int card;			/* card number */
-+	int pad;			/* reserved for future (was type) */
-+	unsigned char id[16];		/* ID of card (user selectable) */
-+	unsigned char driver[16];	/* Driver name */
-+	unsigned char name[32];		/* Short name of soundcard */
-+	unsigned char longname[80];	/* name + info text about soundcard */
-+	unsigned char reserved_[16];	/* reserved for future (was ID of mixer) */
-+	unsigned char mixername[80];	/* visual mixer identification */
-+	unsigned char components[128];	/* card components / fine identification, delimited with one space (AC97 etc..) */
-+};
-+
-+typedef int __bitwise snd_ctl_elem_type_t;
-+#define	SNDRV_CTL_ELEM_TYPE_NONE	((__force snd_ctl_elem_type_t) 0) /* invalid */
-+#define	SNDRV_CTL_ELEM_TYPE_BOOLEAN	((__force snd_ctl_elem_type_t) 1) /* boolean type */
-+#define	SNDRV_CTL_ELEM_TYPE_INTEGER	((__force snd_ctl_elem_type_t) 2) /* integer type */
-+#define	SNDRV_CTL_ELEM_TYPE_ENUMERATED	((__force snd_ctl_elem_type_t) 3) /* enumerated type */
-+#define	SNDRV_CTL_ELEM_TYPE_BYTES	((__force snd_ctl_elem_type_t) 4) /* byte array */
-+#define	SNDRV_CTL_ELEM_TYPE_IEC958	((__force snd_ctl_elem_type_t) 5) /* IEC958 (S/PDIF) setup */
-+#define	SNDRV_CTL_ELEM_TYPE_INTEGER64	((__force snd_ctl_elem_type_t) 6) /* 64-bit integer type */
-+#define	SNDRV_CTL_ELEM_TYPE_LAST	SNDRV_CTL_ELEM_TYPE_INTEGER64
-+
-+typedef int __bitwise snd_ctl_elem_iface_t;
-+#define	SNDRV_CTL_ELEM_IFACE_CARD	((__force snd_ctl_elem_iface_t) 0) /* global control */
-+#define	SNDRV_CTL_ELEM_IFACE_HWDEP	((__force snd_ctl_elem_iface_t) 1) /* hardware dependent device */
-+#define	SNDRV_CTL_ELEM_IFACE_MIXER	((__force snd_ctl_elem_iface_t) 2) /* virtual mixer device */
-+#define	SNDRV_CTL_ELEM_IFACE_PCM	((__force snd_ctl_elem_iface_t) 3) /* PCM device */
-+#define	SNDRV_CTL_ELEM_IFACE_RAWMIDI	((__force snd_ctl_elem_iface_t) 4) /* RawMidi device */
-+#define	SNDRV_CTL_ELEM_IFACE_TIMER	((__force snd_ctl_elem_iface_t) 5) /* timer device */
-+#define	SNDRV_CTL_ELEM_IFACE_SEQUENCER	((__force snd_ctl_elem_iface_t) 6) /* sequencer client */
-+#define	SNDRV_CTL_ELEM_IFACE_LAST	SNDRV_CTL_ELEM_IFACE_SEQUENCER
-+
-+#define SNDRV_CTL_ELEM_ACCESS_READ		(1<<0)
-+#define SNDRV_CTL_ELEM_ACCESS_WRITE		(1<<1)
-+#define SNDRV_CTL_ELEM_ACCESS_READWRITE		(SNDRV_CTL_ELEM_ACCESS_READ|SNDRV_CTL_ELEM_ACCESS_WRITE)
-+#define SNDRV_CTL_ELEM_ACCESS_VOLATILE		(1<<2)	/* control value may be changed without a notification */
-+#define SNDRV_CTL_ELEM_ACCESS_TIMESTAMP		(1<<3)	/* when was control changed */
-+#define SNDRV_CTL_ELEM_ACCESS_TLV_READ		(1<<4)	/* TLV read is possible */
-+#define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE		(1<<5)	/* TLV write is possible */
-+#define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE	(SNDRV_CTL_ELEM_ACCESS_TLV_READ|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE)
-+#define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND	(1<<6)	/* TLV command is possible */
-+#define SNDRV_CTL_ELEM_ACCESS_INACTIVE		(1<<8)	/* control does actually nothing, but may be updated */
-+#define SNDRV_CTL_ELEM_ACCESS_LOCK		(1<<9)	/* write lock */
-+#define SNDRV_CTL_ELEM_ACCESS_OWNER		(1<<10)	/* write lock owner */
-+#define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK	(1<<28)	/* kernel use a TLV callback */
-+#define SNDRV_CTL_ELEM_ACCESS_USER		(1<<29) /* user space element */
-+/* bits 30 and 31 are obsoleted (for indirect access) */
-+
-+/* for further details see the ACPI and PCI power management specification */
-+#define SNDRV_CTL_POWER_D0		0x0000	/* full On */
-+#define SNDRV_CTL_POWER_D1		0x0100	/* partial On */
-+#define SNDRV_CTL_POWER_D2		0x0200	/* partial On */
-+#define SNDRV_CTL_POWER_D3		0x0300	/* Off */
-+#define SNDRV_CTL_POWER_D3hot		(SNDRV_CTL_POWER_D3|0x0000)	/* Off, with power */
-+#define SNDRV_CTL_POWER_D3cold		(SNDRV_CTL_POWER_D3|0x0001)	/* Off, without power */
-+
-+#define SNDRV_CTL_ELEM_ID_NAME_MAXLEN	44
-+
-+struct snd_ctl_elem_id {
-+	unsigned int numid;		/* numeric identifier, zero = invalid */
-+	snd_ctl_elem_iface_t iface;	/* interface identifier */
-+	unsigned int device;		/* device/client number */
-+	unsigned int subdevice;		/* subdevice (substream) number */
-+	unsigned char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];		/* ASCII name of item */
-+	unsigned int index;		/* index of item */
-+};
-+
-+struct snd_ctl_elem_list {
-+	unsigned int offset;		/* W: first element ID to get */
-+	unsigned int space;		/* W: count of element IDs to get */
-+	unsigned int used;		/* R: count of element IDs set */
-+	unsigned int count;		/* R: count of all elements */
-+	struct snd_ctl_elem_id __user *pids; /* R: IDs */
-+	unsigned char reserved[50];
-+};
-+
-+struct snd_ctl_elem_info {
-+	struct snd_ctl_elem_id id;	/* W: element ID */
-+	snd_ctl_elem_type_t type;	/* R: value type - SNDRV_CTL_ELEM_TYPE_* */
-+	unsigned int access;		/* R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* */
-+	unsigned int count;		/* count of values */
-+	__kernel_pid_t owner;		/* owner's PID of this control */
-+	union {
-+		struct {
-+			long min;		/* R: minimum value */
-+			long max;		/* R: maximum value */
-+			long step;		/* R: step (0 variable) */
-+		} integer;
-+		struct {
-+			long long min;		/* R: minimum value */
-+			long long max;		/* R: maximum value */
-+			long long step;		/* R: step (0 variable) */
-+		} integer64;
-+		struct {
-+			unsigned int items;	/* R: number of items */
-+			unsigned int item;	/* W: item number */
-+			char name[64];		/* R: value name */
-+			__u64 names_ptr;	/* W: names list (ELEM_ADD only) */
-+			unsigned int names_length;
-+		} enumerated;
-+		unsigned char reserved[128];
-+	} value;
-+	union {
-+		unsigned short d[4];		/* dimensions */
-+		unsigned short *d_ptr;		/* indirect - obsoleted */
-+	} dimen;
-+	unsigned char reserved[64-4*sizeof(unsigned short)];
-+};
-+
-+struct snd_ctl_elem_value {
-+	struct snd_ctl_elem_id id;	/* W: element ID */
-+	unsigned int indirect: 1;	/* W: indirect access - obsoleted */
-+	union {
-+		union {
-+			long value[128];
-+			long *value_ptr;	/* obsoleted */
-+		} integer;
-+		union {
-+			long long value[64];
-+			long long *value_ptr;	/* obsoleted */
-+		} integer64;
-+		union {
-+			unsigned int item[128];
-+			unsigned int *item_ptr;	/* obsoleted */
-+		} enumerated;
-+		union {
-+			unsigned char data[512];
-+			unsigned char *data_ptr;	/* obsoleted */
-+		} bytes;
-+		struct snd_aes_iec958 iec958;
-+	} value;		/* RO */
-+	struct timespec tstamp;
-+	unsigned char reserved[128-sizeof(struct timespec)];
-+};
-+
-+struct snd_ctl_tlv {
-+	unsigned int numid;	/* control element numeric identification */
-+	unsigned int length;	/* in bytes aligned to 4 */
-+	unsigned int tlv[0];	/* first TLV */
-+};
-+
-+#define SNDRV_CTL_IOCTL_PVERSION	_IOR('U', 0x00, int)
-+#define SNDRV_CTL_IOCTL_CARD_INFO	_IOR('U', 0x01, struct snd_ctl_card_info)
-+#define SNDRV_CTL_IOCTL_ELEM_LIST	_IOWR('U', 0x10, struct snd_ctl_elem_list)
-+#define SNDRV_CTL_IOCTL_ELEM_INFO	_IOWR('U', 0x11, struct snd_ctl_elem_info)
-+#define SNDRV_CTL_IOCTL_ELEM_READ	_IOWR('U', 0x12, struct snd_ctl_elem_value)
-+#define SNDRV_CTL_IOCTL_ELEM_WRITE	_IOWR('U', 0x13, struct snd_ctl_elem_value)
-+#define SNDRV_CTL_IOCTL_ELEM_LOCK	_IOW('U', 0x14, struct snd_ctl_elem_id)
-+#define SNDRV_CTL_IOCTL_ELEM_UNLOCK	_IOW('U', 0x15, struct snd_ctl_elem_id)
-+#define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int)
-+#define SNDRV_CTL_IOCTL_ELEM_ADD	_IOWR('U', 0x17, struct snd_ctl_elem_info)
-+#define SNDRV_CTL_IOCTL_ELEM_REPLACE	_IOWR('U', 0x18, struct snd_ctl_elem_info)
-+#define SNDRV_CTL_IOCTL_ELEM_REMOVE	_IOWR('U', 0x19, struct snd_ctl_elem_id)
-+#define SNDRV_CTL_IOCTL_TLV_READ	_IOWR('U', 0x1a, struct snd_ctl_tlv)
-+#define SNDRV_CTL_IOCTL_TLV_WRITE	_IOWR('U', 0x1b, struct snd_ctl_tlv)
-+#define SNDRV_CTL_IOCTL_TLV_COMMAND	_IOWR('U', 0x1c, struct snd_ctl_tlv)
-+#define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int)
-+#define SNDRV_CTL_IOCTL_HWDEP_INFO	_IOR('U', 0x21, struct snd_hwdep_info)
-+#define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE	_IOR('U', 0x30, int)
-+#define SNDRV_CTL_IOCTL_PCM_INFO	_IOWR('U', 0x31, struct snd_pcm_info)
-+#define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int)
-+#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_POWER		_IOWR('U', 0xd0, int)
-+#define SNDRV_CTL_IOCTL_POWER_STATE	_IOR('U', 0xd1, int)
-+
-+/*
-+ *  Read interface.
-+ */
-+
-+enum sndrv_ctl_event_type {
-+	SNDRV_CTL_EVENT_ELEM = 0,
-+	SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM,
-+};
-+
-+#define SNDRV_CTL_EVENT_MASK_VALUE	(1<<0)	/* element value was changed */
-+#define SNDRV_CTL_EVENT_MASK_INFO	(1<<1)	/* element info was changed */
-+#define SNDRV_CTL_EVENT_MASK_ADD	(1<<2)	/* element was added */
-+#define SNDRV_CTL_EVENT_MASK_TLV	(1<<3)	/* element TLV tree was changed */
-+#define SNDRV_CTL_EVENT_MASK_REMOVE	(~0U)	/* element was removed */
-+
-+struct snd_ctl_event {
-+	int type;	/* event type - SNDRV_CTL_EVENT_* */
-+	union {
-+		struct {
-+			unsigned int mask;
-+			struct snd_ctl_elem_id id;
-+		} elem;
-+		unsigned char data8[60];
-+	} data;
-+};
-+
-+/*
-+ *  Control names
-+ */
-+
-+#define SNDRV_CTL_NAME_NONE				""
-+#define SNDRV_CTL_NAME_PLAYBACK				"Playback "
-+#define SNDRV_CTL_NAME_CAPTURE				"Capture "
-+
-+#define SNDRV_CTL_NAME_IEC958_NONE			""
-+#define SNDRV_CTL_NAME_IEC958_SWITCH			"Switch"
-+#define SNDRV_CTL_NAME_IEC958_VOLUME			"Volume"
-+#define SNDRV_CTL_NAME_IEC958_DEFAULT			"Default"
-+#define SNDRV_CTL_NAME_IEC958_MASK			"Mask"
-+#define SNDRV_CTL_NAME_IEC958_CON_MASK			"Con Mask"
-+#define SNDRV_CTL_NAME_IEC958_PRO_MASK			"Pro Mask"
-+#define SNDRV_CTL_NAME_IEC958_PCM_STREAM		"PCM Stream"
-+#define SNDRV_CTL_NAME_IEC958(expl,direction,what)	"IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what
-+
-+#endif /* _UAPI__SOUND_ASOUND_H */
-diff --git a/include/sound/uapi/asound_fm.h b/include/sound/uapi/asound_fm.h
-new file mode 100644
-index 00000000..8471f404
---- /dev/null
-+++ b/include/sound/uapi/asound_fm.h
-@@ -0,0 +1,135 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+#ifndef __SOUND_ASOUND_FM_H
-+#define __SOUND_ASOUND_FM_H
-+
-+/*
-+ *  Advanced Linux Sound Architecture - ALSA
-+ *
-+ *  Interface file between ALSA driver & user space
-+ *  Copyright (c) 1994-98 by Jaroslav Kysela <perex@perex.cz>,
-+ *                           4Front Technologies
-+ *
-+ *  Direct FM control
-+ *
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-+ *
-+ */
-+
-+#define SNDRV_DM_FM_MODE_OPL2	0x00
-+#define SNDRV_DM_FM_MODE_OPL3	0x01
-+
-+struct snd_dm_fm_info {
-+	unsigned char fm_mode;		/* OPL mode, see SNDRV_DM_FM_MODE_XXX */
-+	unsigned char rhythm;		/* percussion mode flag */
-+};
-+
-+/*
-+ *  Data structure composing an FM "note" or sound event.
-+ */
-+
-+struct snd_dm_fm_voice {
-+	unsigned char op;		/* operator cell (0 or 1) */
-+	unsigned char voice;		/* FM voice (0 to 17) */
-+
-+	unsigned char am;		/* amplitude modulation */
-+	unsigned char vibrato;		/* vibrato effect */
-+	unsigned char do_sustain;	/* sustain phase */
-+	unsigned char kbd_scale;	/* keyboard scaling */
-+	unsigned char harmonic;		/* 4 bits: harmonic and multiplier */
-+	unsigned char scale_level;	/* 2 bits: decrease output freq rises */
-+	unsigned char volume;		/* 6 bits: volume */
-+
-+	unsigned char attack;		/* 4 bits: attack rate */
-+	unsigned char decay;		/* 4 bits: decay rate */
-+	unsigned char sustain;		/* 4 bits: sustain level */
-+	unsigned char release;		/* 4 bits: release rate */
-+
-+	unsigned char feedback;		/* 3 bits: feedback for op0 */
-+	unsigned char connection;	/* 0 for serial, 1 for parallel */
-+	unsigned char left;		/* stereo left */
-+	unsigned char right;		/* stereo right */
-+	unsigned char waveform;		/* 3 bits: waveform shape */
-+};
-+
-+/*
-+ *  This describes an FM note by its voice, octave, frequency number (10bit)
-+ *  and key on/off.
-+ */
-+
-+struct snd_dm_fm_note {
-+	unsigned char voice;	/* 0-17 voice channel */
-+	unsigned char octave;	/* 3 bits: what octave to play */
-+	unsigned int fnum;	/* 10 bits: frequency number */
-+	unsigned char key_on;	/* set for active, clear for silent */
-+};
-+
-+/*
-+ *  FM parameters that apply globally to all voices, and thus are not "notes"
-+ */
-+
-+struct snd_dm_fm_params {
-+	unsigned char am_depth;		/* amplitude modulation depth (1=hi) */
-+	unsigned char vib_depth;	/* vibrato depth (1=hi) */
-+	unsigned char kbd_split;	/* keyboard split */
-+	unsigned char rhythm;		/* percussion mode select */
-+
-+	/* This block is the percussion instrument data */
-+	unsigned char bass;
-+	unsigned char snare;
-+	unsigned char tomtom;
-+	unsigned char cymbal;
-+	unsigned char hihat;
-+};
-+
-+/*
-+ *  FM mode ioctl settings
-+ */
-+
-+#define SNDRV_DM_FM_IOCTL_INFO		_IOR('H', 0x20, struct snd_dm_fm_info)
-+#define SNDRV_DM_FM_IOCTL_RESET		_IO ('H', 0x21)
-+#define SNDRV_DM_FM_IOCTL_PLAY_NOTE	_IOW('H', 0x22, struct snd_dm_fm_note)
-+#define SNDRV_DM_FM_IOCTL_SET_VOICE	_IOW('H', 0x23, struct snd_dm_fm_voice)
-+#define SNDRV_DM_FM_IOCTL_SET_PARAMS	_IOW('H', 0x24, struct snd_dm_fm_params)
-+#define SNDRV_DM_FM_IOCTL_SET_MODE	_IOW('H', 0x25, int)
-+/* for OPL3 only */
-+#define SNDRV_DM_FM_IOCTL_SET_CONNECTION	_IOW('H', 0x26, int)
-+/* SBI patch management */
-+#define SNDRV_DM_FM_IOCTL_CLEAR_PATCHES	_IO ('H', 0x40)
-+
-+#define SNDRV_DM_FM_OSS_IOCTL_RESET		0x20
-+#define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE		0x21
-+#define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE		0x22
-+#define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS	0x23
-+#define SNDRV_DM_FM_OSS_IOCTL_SET_MODE		0x24
-+#define SNDRV_DM_FM_OSS_IOCTL_SET_OPL		0x25
-+
-+/*
-+ * Patch Record - fixed size for write
-+ */
-+
-+#define FM_KEY_SBI	"SBI\032"
-+#define FM_KEY_2OP	"2OP\032"
-+#define FM_KEY_4OP	"4OP\032"
-+
-+struct sbi_patch {
-+	unsigned char prog;
-+	unsigned char bank;
-+	char key[4];
-+	char name[25];
-+	char extension[7];
-+	unsigned char data[32];
-+};
-+
-+#endif /* __SOUND_ASOUND_FM_H */
-diff --git a/include/sound/uapi/emu10k1.h b/include/sound/uapi/emu10k1.h
-new file mode 100644
-index 00000000..c1150e4d
---- /dev/null
-+++ b/include/sound/uapi/emu10k1.h
-@@ -0,0 +1,395 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+/*
-+ *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
-+ *		     Creative Labs, Inc.
-+ *  Definitions for EMU10K1 (SB Live!) chips
-+ *
-+ *
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-+ *
-+ */
-+#ifndef _UAPI__SOUND_EMU10K1_H
-+#define _UAPI__SOUND_EMU10K1_H
-+
-+/*
-+ * ---- FX8010 ----
-+ */
-+
-+#define EMU10K1_CARD_CREATIVE			0x00000000
-+#define EMU10K1_CARD_EMUAPS			0x00000001
-+
-+#define EMU10K1_FX8010_PCM_COUNT		8
-+
-+/*
-+ * Following definition is copied from linux/types.h to support compiling
-+ * this header file in userspace since they are not generally available for
-+ * uapi headers.
-+ */
-+#define __EMU10K1_DECLARE_BITMAP(name,bits) \
-+	unsigned long name[(bits) / (sizeof(unsigned long) * 8)]
-+
-+/* instruction set */
-+#define iMAC0	 0x00	/* R = A + (X * Y >> 31)   ; saturation */
-+#define iMAC1	 0x01	/* R = A + (-X * Y >> 31)  ; saturation */
-+#define iMAC2	 0x02	/* R = A + (X * Y >> 31)   ; wraparound */
-+#define iMAC3	 0x03	/* R = A + (-X * Y >> 31)  ; wraparound */
-+#define iMACINT0 0x04	/* R = A + X * Y	   ; saturation */
-+#define iMACINT1 0x05	/* R = A + X * Y	   ; wraparound (31-bit) */
-+#define iACC3	 0x06	/* R = A + X + Y	   ; saturation */
-+#define iMACMV   0x07	/* R = A, acc += X * Y >> 31 */
-+#define iANDXOR  0x08	/* R = (A & X) ^ Y */
-+#define iTSTNEG  0x09	/* R = (A >= Y) ? X : ~X */
-+#define iLIMITGE 0x0a	/* R = (A >= Y) ? X : Y */
-+#define iLIMITLT 0x0b	/* R = (A < Y) ? X : Y */
-+#define iLOG	 0x0c	/* R = linear_data, A (log_data), X (max_exp), Y (format_word) */
-+#define iEXP	 0x0d	/* R = log_data, A (linear_data), X (max_exp), Y (format_word) */
-+#define iINTERP  0x0e	/* R = A + (X * (Y - A) >> 31)  ; saturation */
-+#define iSKIP    0x0f	/* R = A (cc_reg), X (count), Y (cc_test) */
-+
-+/* GPRs */
-+#define FXBUS(x)	(0x00 + (x))	/* x = 0x00 - 0x0f */
-+#define EXTIN(x)	(0x10 + (x))	/* x = 0x00 - 0x0f */
-+#define EXTOUT(x)	(0x20 + (x))	/* x = 0x00 - 0x0f physical outs -> FXWC low 16 bits */
-+#define FXBUS2(x)	(0x30 + (x))	/* x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits */
-+					/* NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 */
-+
-+#define C_00000000	0x40
-+#define C_00000001	0x41
-+#define C_00000002	0x42
-+#define C_00000003	0x43
-+#define C_00000004	0x44
-+#define C_00000008	0x45
-+#define C_00000010	0x46
-+#define C_00000020	0x47
-+#define C_00000100	0x48
-+#define C_00010000	0x49
-+#define C_00080000	0x4a
-+#define C_10000000	0x4b
-+#define C_20000000	0x4c
-+#define C_40000000	0x4d
-+#define C_80000000	0x4e
-+#define C_7fffffff	0x4f
-+#define C_ffffffff	0x50
-+#define C_fffffffe	0x51
-+#define C_c0000000	0x52
-+#define C_4f1bbcdc	0x53
-+#define C_5a7ef9db	0x54
-+#define C_00100000	0x55		/* ?? */
-+#define GPR_ACCU	0x56		/* ACCUM, accumulator */
-+#define GPR_COND	0x57		/* CCR, condition register */
-+#define GPR_NOISE0	0x58		/* noise source */
-+#define GPR_NOISE1	0x59		/* noise source */
-+#define GPR_IRQ		0x5a		/* IRQ register */
-+#define GPR_DBAC	0x5b		/* TRAM Delay Base Address Counter */
-+#define GPR(x)		(FXGPREGBASE + (x)) /* free GPRs: x = 0x00 - 0xff */
-+#define ITRAM_DATA(x)	(TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */
-+#define ETRAM_DATA(x)	(TANKMEMDATAREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */
-+#define ITRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0x7f */
-+#define ETRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0x80 + (x)) /* x = 0x00 - 0x1f */
-+
-+#define A_ITRAM_DATA(x)	(TANKMEMDATAREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
-+#define A_ETRAM_DATA(x)	(TANKMEMDATAREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
-+#define A_ITRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
-+#define A_ETRAM_ADDR(x)	(TANKMEMADDRREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
-+#define A_ITRAM_CTL(x)	(A_TANKMEMCTLREGBASE + 0x00 + (x)) /* x = 0x00 - 0xbf */
-+#define A_ETRAM_CTL(x)	(A_TANKMEMCTLREGBASE + 0xc0 + (x)) /* x = 0x00 - 0x3f */
-+
-+#define A_FXBUS(x)	(0x00 + (x))	/* x = 0x00 - 0x3f FX buses */
-+#define A_EXTIN(x)	(0x40 + (x))	/* x = 0x00 - 0x0f physical ins */
-+#define A_P16VIN(x)	(0x50 + (x))	/* x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" */
-+#define A_EXTOUT(x)	(0x60 + (x))	/* x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown   */
-+#define A_FXBUS2(x)	(0x80 + (x))	/* x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 */
-+#define A_EMU32OUTH(x)	(0xa0 + (x))	/* x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" - ??? */
-+#define A_EMU32OUTL(x)	(0xb0 + (x))	/* x = 0x00 - 0x0f "EMU32_OUT_1 - _F" - ??? */
-+#define A3_EMU32IN(x)	(0x160 + (x))	/* x = 0x00 - 0x3f "EMU32_IN_00 - _3F" - Only when .device = 0x0008 */
-+#define A3_EMU32OUT(x)	(0x1E0 + (x))	/* x = 0x00 - 0x0f "EMU32_OUT_00 - _3F" - Only when .device = 0x0008 */
-+#define A_GPR(x)	(A_FXGPREGBASE + (x))
-+
-+/* cc_reg constants */
-+#define CC_REG_NORMALIZED C_00000001
-+#define CC_REG_BORROW	C_00000002
-+#define CC_REG_MINUS	C_00000004
-+#define CC_REG_ZERO	C_00000008
-+#define CC_REG_SATURATE	C_00000010
-+#define CC_REG_NONZERO	C_00000100
-+
-+/* FX buses */
-+#define FXBUS_PCM_LEFT		0x00
-+#define FXBUS_PCM_RIGHT		0x01
-+#define FXBUS_PCM_LEFT_REAR	0x02
-+#define FXBUS_PCM_RIGHT_REAR	0x03
-+#define FXBUS_MIDI_LEFT		0x04
-+#define FXBUS_MIDI_RIGHT	0x05
-+#define FXBUS_PCM_CENTER	0x06
-+#define FXBUS_PCM_LFE		0x07
-+#define FXBUS_PCM_LEFT_FRONT	0x08
-+#define FXBUS_PCM_RIGHT_FRONT	0x09
-+#define FXBUS_MIDI_REVERB	0x0c
-+#define FXBUS_MIDI_CHORUS	0x0d
-+#define FXBUS_PCM_LEFT_SIDE	0x0e
-+#define FXBUS_PCM_RIGHT_SIDE	0x0f
-+#define FXBUS_PT_LEFT		0x14
-+#define FXBUS_PT_RIGHT		0x15
-+
-+/* Inputs */
-+#define EXTIN_AC97_L	   0x00	/* AC'97 capture channel - left */
-+#define EXTIN_AC97_R	   0x01	/* AC'97 capture channel - right */
-+#define EXTIN_SPDIF_CD_L   0x02	/* internal S/PDIF CD - onboard - left */
-+#define EXTIN_SPDIF_CD_R   0x03	/* internal S/PDIF CD - onboard - right */
-+#define EXTIN_ZOOM_L	   0x04	/* Zoom Video I2S - left */
-+#define EXTIN_ZOOM_R	   0x05	/* Zoom Video I2S - right */
-+#define EXTIN_TOSLINK_L	   0x06	/* LiveDrive - TOSLink Optical - left */
-+#define EXTIN_TOSLINK_R    0x07	/* LiveDrive - TOSLink Optical - right */
-+#define EXTIN_LINE1_L	   0x08	/* LiveDrive - Line/Mic 1 - left */
-+#define EXTIN_LINE1_R	   0x09	/* LiveDrive - Line/Mic 1 - right */
-+#define EXTIN_COAX_SPDIF_L 0x0a	/* LiveDrive - Coaxial S/PDIF - left */
-+#define EXTIN_COAX_SPDIF_R 0x0b /* LiveDrive - Coaxial S/PDIF - right */
-+#define EXTIN_LINE2_L	   0x0c	/* LiveDrive - Line/Mic 2 - left */
-+#define EXTIN_LINE2_R	   0x0d	/* LiveDrive - Line/Mic 2 - right */
-+
-+/* Outputs */
-+#define EXTOUT_AC97_L	   0x00	/* AC'97 playback channel - left */
-+#define EXTOUT_AC97_R	   0x01	/* AC'97 playback channel - right */
-+#define EXTOUT_TOSLINK_L   0x02	/* LiveDrive - TOSLink Optical - left */
-+#define EXTOUT_TOSLINK_R   0x03	/* LiveDrive - TOSLink Optical - right */
-+#define EXTOUT_AC97_CENTER 0x04	/* SB Live 5.1 - center */
-+#define EXTOUT_AC97_LFE	   0x05 /* SB Live 5.1 - LFE */
-+#define EXTOUT_HEADPHONE_L 0x06	/* LiveDrive - Headphone - left */
-+#define EXTOUT_HEADPHONE_R 0x07	/* LiveDrive - Headphone - right */
-+#define EXTOUT_REAR_L	   0x08	/* Rear channel - left */
-+#define EXTOUT_REAR_R	   0x09	/* Rear channel - right */
-+#define EXTOUT_ADC_CAP_L   0x0a	/* ADC Capture buffer - left */
-+#define EXTOUT_ADC_CAP_R   0x0b	/* ADC Capture buffer - right */
-+#define EXTOUT_MIC_CAP	   0x0c	/* MIC Capture buffer */
-+#define EXTOUT_AC97_REAR_L 0x0d	/* SB Live 5.1 (c) 2003 - Rear Left */
-+#define EXTOUT_AC97_REAR_R 0x0e	/* SB Live 5.1 (c) 2003 - Rear Right */
-+#define EXTOUT_ACENTER	   0x11 /* Analog Center */
-+#define EXTOUT_ALFE	   0x12 /* Analog LFE */
-+
-+/* Audigy Inputs */
-+#define A_EXTIN_AC97_L		0x00	/* AC'97 capture channel - left */
-+#define A_EXTIN_AC97_R		0x01	/* AC'97 capture channel - right */
-+#define A_EXTIN_SPDIF_CD_L	0x02	/* digital CD left */
-+#define A_EXTIN_SPDIF_CD_R	0x03	/* digital CD left */
-+#define A_EXTIN_OPT_SPDIF_L     0x04    /* audigy drive Optical SPDIF - left */
-+#define A_EXTIN_OPT_SPDIF_R     0x05    /*                              right */ 
-+#define A_EXTIN_LINE2_L		0x08	/* audigy drive line2/mic2 - left */
-+#define A_EXTIN_LINE2_R		0x09	/*                           right */
-+#define A_EXTIN_ADC_L		0x0a    /* Philips ADC - left */
-+#define A_EXTIN_ADC_R		0x0b    /*               right */
-+#define A_EXTIN_AUX2_L		0x0c	/* audigy drive aux2 - left */
-+#define A_EXTIN_AUX2_R		0x0d	/*                   - right */
-+
-+/* Audigiy Outputs */
-+#define A_EXTOUT_FRONT_L	0x00	/* digital front left */
-+#define A_EXTOUT_FRONT_R	0x01	/*               right */
-+#define A_EXTOUT_CENTER		0x02	/* digital front center */
-+#define A_EXTOUT_LFE		0x03	/* digital front lfe */
-+#define A_EXTOUT_HEADPHONE_L	0x04	/* headphone audigy drive left */
-+#define A_EXTOUT_HEADPHONE_R	0x05	/*                        right */
-+#define A_EXTOUT_REAR_L		0x06	/* digital rear left */
-+#define A_EXTOUT_REAR_R		0x07	/*              right */
-+#define A_EXTOUT_AFRONT_L	0x08	/* analog front left */
-+#define A_EXTOUT_AFRONT_R	0x09	/*              right */
-+#define A_EXTOUT_ACENTER	0x0a	/* analog center */
-+#define A_EXTOUT_ALFE		0x0b	/* analog LFE */
-+#define A_EXTOUT_ASIDE_L	0x0c	/* analog side left  - Audigy 2 ZS */
-+#define A_EXTOUT_ASIDE_R	0x0d	/*             right - Audigy 2 ZS */
-+#define A_EXTOUT_AREAR_L	0x0e	/* analog rear left */
-+#define A_EXTOUT_AREAR_R	0x0f	/*             right */
-+#define A_EXTOUT_AC97_L		0x10	/* AC97 left (front) */
-+#define A_EXTOUT_AC97_R		0x11	/*      right */
-+#define A_EXTOUT_ADC_CAP_L	0x16	/* ADC capture buffer left */
-+#define A_EXTOUT_ADC_CAP_R	0x17	/*                    right */
-+#define A_EXTOUT_MIC_CAP	0x18	/* Mic capture buffer */
-+
-+/* Audigy constants */
-+#define A_C_00000000	0xc0
-+#define A_C_00000001	0xc1
-+#define A_C_00000002	0xc2
-+#define A_C_00000003	0xc3
-+#define A_C_00000004	0xc4
-+#define A_C_00000008	0xc5
-+#define A_C_00000010	0xc6
-+#define A_C_00000020	0xc7
-+#define A_C_00000100	0xc8
-+#define A_C_00010000	0xc9
-+#define A_C_00000800	0xca
-+#define A_C_10000000	0xcb
-+#define A_C_20000000	0xcc
-+#define A_C_40000000	0xcd
-+#define A_C_80000000	0xce
-+#define A_C_7fffffff	0xcf
-+#define A_C_ffffffff	0xd0
-+#define A_C_fffffffe	0xd1
-+#define A_C_c0000000	0xd2
-+#define A_C_4f1bbcdc	0xd3
-+#define A_C_5a7ef9db	0xd4
-+#define A_C_00100000	0xd5
-+#define A_GPR_ACCU	0xd6		/* ACCUM, accumulator */
-+#define A_GPR_COND	0xd7		/* CCR, condition register */
-+#define A_GPR_NOISE0	0xd8		/* noise source */
-+#define A_GPR_NOISE1	0xd9		/* noise source */
-+#define A_GPR_IRQ	0xda		/* IRQ register */
-+#define A_GPR_DBAC	0xdb		/* TRAM Delay Base Address Counter - internal */
-+#define A_GPR_DBACE	0xde		/* TRAM Delay Base Address Counter - external */
-+
-+/* definitions for debug register */
-+#define EMU10K1_DBG_ZC			0x80000000	/* zero tram counter */
-+#define EMU10K1_DBG_SATURATION_OCCURED	0x02000000	/* saturation control */
-+#define EMU10K1_DBG_SATURATION_ADDR	0x01ff0000	/* saturation address */
-+#define EMU10K1_DBG_SINGLE_STEP		0x00008000	/* single step mode */
-+#define EMU10K1_DBG_STEP		0x00004000	/* start single step */
-+#define EMU10K1_DBG_CONDITION_CODE	0x00003e00	/* condition code */
-+#define EMU10K1_DBG_SINGLE_STEP_ADDR	0x000001ff	/* single step address */
-+
-+/* tank memory address line */
-+#ifndef __KERNEL__
-+#define TANKMEMADDRREG_ADDR_MASK 0x000fffff	/* 20 bit tank address field			*/
-+#define TANKMEMADDRREG_CLEAR	 0x00800000	/* Clear tank memory				*/
-+#define TANKMEMADDRREG_ALIGN	 0x00400000	/* Align read or write relative to tank access	*/
-+#define TANKMEMADDRREG_WRITE	 0x00200000	/* Write to tank memory				*/
-+#define TANKMEMADDRREG_READ	 0x00100000	/* Read from tank memory			*/
-+#endif
-+
-+struct snd_emu10k1_fx8010_info {
-+	unsigned int internal_tram_size;	/* in samples */
-+	unsigned int external_tram_size;	/* in samples */
-+	char fxbus_names[16][32];		/* names of FXBUSes */
-+	char extin_names[16][32];		/* names of external inputs */
-+	char extout_names[32][32];		/* names of external outputs */
-+	unsigned int gpr_controls;		/* count of GPR controls */
-+};
-+
-+#define EMU10K1_GPR_TRANSLATION_NONE		0
-+#define EMU10K1_GPR_TRANSLATION_TABLE100	1
-+#define EMU10K1_GPR_TRANSLATION_BASS		2
-+#define EMU10K1_GPR_TRANSLATION_TREBLE		3
-+#define EMU10K1_GPR_TRANSLATION_ONOFF		4
-+
-+enum emu10k1_ctl_elem_iface {
-+	EMU10K1_CTL_ELEM_IFACE_MIXER = 2,	/* virtual mixer device */
-+	EMU10K1_CTL_ELEM_IFACE_PCM = 3,		/* PCM device */
-+};
-+
-+struct emu10k1_ctl_elem_id {
-+	unsigned int pad;		/* don't use */
-+	int iface;			/* interface identifier */
-+	unsigned int device;		/* device/client number */
-+	unsigned int subdevice;		/* subdevice (substream) number */
-+	unsigned char name[44];		/* ASCII name of item */
-+	unsigned int index;		/* index of item */
-+};
-+
-+struct snd_emu10k1_fx8010_control_gpr {
-+	struct emu10k1_ctl_elem_id id;	/* full control ID definition */
-+	unsigned int vcount;		/* visible count */
-+	unsigned int count;		/* count of GPR (1..16) */
-+	unsigned short gpr[32];		/* GPR number(s) */
-+	unsigned int value[32];		/* initial values */
-+	unsigned int min;		/* minimum range */
-+	unsigned int max;		/* maximum range */
-+	unsigned int translation;	/* translation type (EMU10K1_GPR_TRANSLATION*) */
-+	const unsigned int *tlv;
-+};
-+
-+/* old ABI without TLV support */
-+struct snd_emu10k1_fx8010_control_old_gpr {
-+	struct emu10k1_ctl_elem_id id;
-+	unsigned int vcount;
-+	unsigned int count;
-+	unsigned short gpr[32];
-+	unsigned int value[32];
-+	unsigned int min;
-+	unsigned int max;
-+	unsigned int translation;
-+};
-+
-+struct snd_emu10k1_fx8010_code {
-+	char name[128];
-+
-+	__EMU10K1_DECLARE_BITMAP(gpr_valid, 0x200); /* bitmask of valid initializers */
-+	__u32 *gpr_map;			/* initializers */
-+
-+	unsigned int gpr_add_control_count; /* count of GPR controls to add/replace */
-+	struct snd_emu10k1_fx8010_control_gpr *gpr_add_controls; /* GPR controls to add/replace */
-+
-+	unsigned int gpr_del_control_count; /* count of GPR controls to remove */
-+	struct emu10k1_ctl_elem_id *gpr_del_controls; /* IDs of GPR controls to remove */
-+
-+	unsigned int gpr_list_control_count; /* count of GPR controls to list */
-+	unsigned int gpr_list_control_total; /* total count of GPR controls */
-+	struct snd_emu10k1_fx8010_control_gpr *gpr_list_controls; /* listed GPR controls */
-+
-+	__EMU10K1_DECLARE_BITMAP(tram_valid, 0x100); /* bitmask of valid initializers */
-+	__u32 *tram_data_map;		  /* data initializers */
-+	__u32 *tram_addr_map;		  /* map initializers */
-+
-+	__EMU10K1_DECLARE_BITMAP(code_valid, 1024); /* bitmask of valid instructions */
-+	__u32 *code;			  /* one instruction - 64 bits */
-+};
-+
-+struct snd_emu10k1_fx8010_tram {
-+	unsigned int address;		/* 31.bit == 1 -> external TRAM */
-+	unsigned int size;		/* size in samples (4 bytes) */
-+	unsigned int *samples;		/* pointer to samples (20-bit) */
-+					/* NULL->clear memory */
-+};
-+
-+struct snd_emu10k1_fx8010_pcm_rec {
-+	unsigned int substream;		/* substream number */
-+	unsigned int res1;		/* reserved */
-+	unsigned int channels;		/* 16-bit channels count, zero = remove this substream */
-+	unsigned int tram_start;	/* ring buffer position in TRAM (in samples) */
-+	unsigned int buffer_size;	/* count of buffered samples */
-+	unsigned short gpr_size;		/* GPR containing size of ringbuffer in samples (host) */
-+	unsigned short gpr_ptr;		/* GPR containing current pointer in the ring buffer (host = reset, FX8010) */
-+	unsigned short gpr_count;	/* GPR containing count of samples between two interrupts (host) */
-+	unsigned short gpr_tmpcount;	/* GPR containing current count of samples to interrupt (host = set, FX8010) */
-+	unsigned short gpr_trigger;	/* GPR containing trigger (activate) information (host) */
-+	unsigned short gpr_running;	/* GPR containing info if PCM is running (FX8010) */
-+	unsigned char pad;		/* reserved */
-+	unsigned char etram[32];	/* external TRAM address & data (one per channel) */
-+	unsigned int res2;		/* reserved */
-+};
-+
-+#define SNDRV_EMU10K1_VERSION		SNDRV_PROTOCOL_VERSION(1, 0, 1)
-+
-+#define SNDRV_EMU10K1_IOCTL_INFO	_IOR ('H', 0x10, struct snd_emu10k1_fx8010_info)
-+#define SNDRV_EMU10K1_IOCTL_CODE_POKE	_IOW ('H', 0x11, struct snd_emu10k1_fx8010_code)
-+#define SNDRV_EMU10K1_IOCTL_CODE_PEEK	_IOWR('H', 0x12, struct snd_emu10k1_fx8010_code)
-+#define SNDRV_EMU10K1_IOCTL_TRAM_SETUP	_IOW ('H', 0x20, int)
-+#define SNDRV_EMU10K1_IOCTL_TRAM_POKE	_IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram)
-+#define SNDRV_EMU10K1_IOCTL_TRAM_PEEK	_IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram)
-+#define SNDRV_EMU10K1_IOCTL_PCM_POKE	_IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec)
-+#define SNDRV_EMU10K1_IOCTL_PCM_PEEK	_IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec)
-+#define SNDRV_EMU10K1_IOCTL_PVERSION	_IOR ('H', 0x40, int)
-+#define SNDRV_EMU10K1_IOCTL_STOP	_IO  ('H', 0x80)
-+#define SNDRV_EMU10K1_IOCTL_CONTINUE	_IO  ('H', 0x81)
-+#define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82)
-+#define SNDRV_EMU10K1_IOCTL_SINGLE_STEP	_IOW ('H', 0x83, int)
-+#define SNDRV_EMU10K1_IOCTL_DBG_READ	_IOR ('H', 0x84, int)
-+
-+#ifndef __KERNEL__
-+/* typedefs for compatibility to user-space */
-+typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t;
-+typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t;
-+typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t;
-+typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t;
-+typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t;
-+typedef struct emu10k1_ctl_elem_id emu10k1_ctl_elem_id_t;
-+#endif
-+
-+#endif /* _UAPI__SOUND_EMU10K1_H */
-diff --git a/include/sound/uapi/hdsp.h b/include/sound/uapi/hdsp.h
-new file mode 100644
-index 00000000..88c92a3f
---- /dev/null
-+++ b/include/sound/uapi/hdsp.h
-@@ -0,0 +1,109 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+#ifndef __SOUND_HDSP_H
-+#define __SOUND_HDSP_H
-+
-+/*
-+ *   Copyright (C) 2003 Thomas Charbonnel (thomas@undata.org)
-+ *    
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-+ */
-+
-+#define HDSP_MATRIX_MIXER_SIZE 2048
-+
-+enum HDSP_IO_Type {
-+	Digiface,
-+	Multiface,
-+	H9652,
-+	H9632,
-+	RPM,
-+	Undefined,
-+};
-+
-+struct hdsp_peak_rms {
-+	__u32 input_peaks[26];
-+	__u32 playback_peaks[26];
-+	__u32 output_peaks[28];
-+	__u64 input_rms[26];
-+	__u64 playback_rms[26];
-+	/* These are only used for H96xx cards */
-+	__u64 output_rms[26];
-+};
-+
-+#define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms)
-+
-+struct hdsp_config_info {
-+	unsigned char pref_sync_ref;
-+	unsigned char wordclock_sync_check;
-+	unsigned char spdif_sync_check;
-+	unsigned char adatsync_sync_check;
-+	unsigned char adat_sync_check[3];
-+	unsigned char spdif_in;
-+	unsigned char spdif_out;
-+	unsigned char spdif_professional;
-+	unsigned char spdif_emphasis;
-+	unsigned char spdif_nonaudio;
-+	unsigned int spdif_sample_rate;
-+	unsigned int system_sample_rate;
-+	unsigned int autosync_sample_rate;
-+	unsigned char system_clock_mode;
-+	unsigned char clock_source;
-+	unsigned char autosync_ref;
-+	unsigned char line_out;
-+	unsigned char passthru; 
-+	unsigned char da_gain;
-+	unsigned char ad_gain;
-+	unsigned char phone_gain;
-+	unsigned char xlr_breakout_cable;
-+	unsigned char analog_extension_board;
-+};
-+
-+#define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info)
-+
-+struct hdsp_firmware {
-+	void *firmware_data;	/* 24413 x 4 bytes */
-+};
-+
-+#define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware)
-+
-+struct hdsp_version {
-+	enum HDSP_IO_Type io_type;
-+	unsigned short firmware_rev;
-+};
-+
-+#define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version)
-+
-+struct hdsp_mixer {
-+	unsigned short matrix[HDSP_MATRIX_MIXER_SIZE];
-+};
-+
-+#define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer)
-+
-+struct hdsp_9632_aeb {
-+	int aebi;
-+	int aebo;
-+};
-+
-+#define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb)
-+
-+/* typedefs for compatibility to user-space */
-+typedef enum HDSP_IO_Type HDSP_IO_Type;
-+typedef struct hdsp_peak_rms hdsp_peak_rms_t;
-+typedef struct hdsp_config_info hdsp_config_info_t;
-+typedef struct hdsp_firmware hdsp_firmware_t;
-+typedef struct hdsp_version hdsp_version_t;
-+typedef struct hdsp_mixer hdsp_mixer_t;
-+typedef struct hdsp_9632_aeb hdsp_9632_aeb_t;
-+
-+#endif /* __SOUND_HDSP_H */
-diff --git a/include/sound/uapi/hdspm.h b/include/sound/uapi/hdspm.h
-new file mode 100644
-index 00000000..2d91f90e
---- /dev/null
-+++ b/include/sound/uapi/hdspm.h
-@@ -0,0 +1,230 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+#ifndef __SOUND_HDSPM_H
-+#define __SOUND_HDSPM_H
-+/*
-+ *   Copyright (C) 2003 Winfried Ritsch (IEM)
-+ *   based on hdsp.h from Thomas Charbonnel (thomas@undata.org)
-+ *
-+ *
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-+ */
-+
-+/* Maximum channels is 64 even on 56Mode you have 64playbacks to matrix */
-+#define HDSPM_MAX_CHANNELS      64
-+
-+enum hdspm_io_type {
-+	MADI,
-+	MADIface,
-+	AIO,
-+	AES32,
-+	RayDAT
-+};
-+
-+enum hdspm_speed {
-+	ss,
-+	ds,
-+	qs
-+};
-+
-+/* -------------------- IOCTL Peak/RMS Meters -------------------- */
-+
-+struct hdspm_peak_rms {
-+	__u32 input_peaks[64];
-+	__u32 playback_peaks[64];
-+	__u32 output_peaks[64];
-+
-+	__u64 input_rms[64];
-+	__u64 playback_rms[64];
-+	__u64 output_rms[64];
-+
-+	__u8 speed; /* enum {ss, ds, qs} */
-+	int status2;
-+};
-+
-+#define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS \
-+	_IOR('H', 0x42, struct hdspm_peak_rms)
-+
-+/* ------------ CONFIG block IOCTL ---------------------- */
-+
-+struct hdspm_config {
-+	unsigned char pref_sync_ref;
-+	unsigned char wordclock_sync_check;
-+	unsigned char madi_sync_check;
-+	unsigned int system_sample_rate;
-+	unsigned int autosync_sample_rate;
-+	unsigned char system_clock_mode;
-+	unsigned char clock_source;
-+	unsigned char autosync_ref;
-+	unsigned char line_out;
-+	unsigned int passthru;
-+	unsigned int analog_out;
-+};
-+
-+#define SNDRV_HDSPM_IOCTL_GET_CONFIG \
-+	_IOR('H', 0x41, struct hdspm_config)
-+
-+/*
-+ * If there's a TCO (TimeCode Option) board installed,
-+ * there are further options and status data available.
-+ * The hdspm_ltc structure contains the current SMPTE
-+ * timecode and some status information and can be
-+ * obtained via SNDRV_HDSPM_IOCTL_GET_LTC or in the
-+ * hdspm_status struct.
-+ */
-+
-+enum hdspm_ltc_format {
-+	format_invalid,
-+	fps_24,
-+	fps_25,
-+	fps_2997,
-+	fps_30
-+};
-+
-+enum hdspm_ltc_frame {
-+	frame_invalid,
-+	drop_frame,
-+	full_frame
-+};
-+
-+enum hdspm_ltc_input_format {
-+	ntsc,
-+	pal,
-+	no_video
-+};
-+
-+struct hdspm_ltc {
-+	unsigned int ltc;
-+
-+	enum hdspm_ltc_format format;
-+	enum hdspm_ltc_frame frame;
-+	enum hdspm_ltc_input_format input_format;
-+};
-+
-+#define SNDRV_HDSPM_IOCTL_GET_LTC _IOR('H', 0x46, struct hdspm_ltc)
-+
-+/*
-+ * The status data reflects the device's current state
-+ * as determined by the card's configuration and
-+ * connection status.
-+ */
-+
-+enum hdspm_sync {
-+	hdspm_sync_no_lock = 0,
-+	hdspm_sync_lock = 1,
-+	hdspm_sync_sync = 2
-+};
-+
-+enum hdspm_madi_input {
-+	hdspm_input_optical = 0,
-+	hdspm_input_coax = 1
-+};
-+
-+enum hdspm_madi_channel_format {
-+	hdspm_format_ch_64 = 0,
-+	hdspm_format_ch_56 = 1
-+};
-+
-+enum hdspm_madi_frame_format {
-+	hdspm_frame_48 = 0,
-+	hdspm_frame_96 = 1
-+};
-+
-+enum hdspm_syncsource {
-+	syncsource_wc = 0,
-+	syncsource_madi = 1,
-+	syncsource_tco = 2,
-+	syncsource_sync = 3,
-+	syncsource_none = 4
-+};
-+
-+struct hdspm_status {
-+	__u8 card_type; /* enum hdspm_io_type */
-+	enum hdspm_syncsource autosync_source;
-+
-+	__u64 card_clock;
-+	__u32 master_period;
-+
-+	union {
-+		struct {
-+			__u8 sync_wc; /* enum hdspm_sync */
-+			__u8 sync_madi; /* enum hdspm_sync */
-+			__u8 sync_tco; /* enum hdspm_sync */
-+			__u8 sync_in; /* enum hdspm_sync */
-+			__u8 madi_input; /* enum hdspm_madi_input */
-+			__u8 channel_format; /* enum hdspm_madi_channel_format */
-+			__u8 frame_format; /* enum hdspm_madi_frame_format */
-+		} madi;
-+	} card_specific;
-+};
-+
-+#define SNDRV_HDSPM_IOCTL_GET_STATUS \
-+	_IOR('H', 0x47, struct hdspm_status)
-+
-+/*
-+ * Get information about the card and its add-ons.
-+ */
-+
-+#define HDSPM_ADDON_TCO 1
-+
-+struct hdspm_version {
-+	__u8 card_type; /* enum hdspm_io_type */
-+	char cardname[20];
-+	unsigned int serial;
-+	unsigned short firmware_rev;
-+	int addons;
-+};
-+
-+#define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x48, struct hdspm_version)
-+
-+/* ------------- get Matrix Mixer IOCTL --------------- */
-+
-+/* MADI mixer: 64inputs+64playback in 64outputs = 8192 => *4Byte =
-+ * 32768 Bytes
-+ */
-+
-+/* organisation is 64 channelfader in a continuous memory block */
-+/* equivalent to hardware definition, maybe for future feature of mmap of
-+ * them
-+ */
-+/* each of 64 outputs has 64 infader and 64 outfader:
-+   Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] */
-+
-+#define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS
-+
-+struct hdspm_channelfader {
-+	unsigned int in[HDSPM_MIXER_CHANNELS];
-+	unsigned int pb[HDSPM_MIXER_CHANNELS];
-+};
-+
-+struct hdspm_mixer {
-+	struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS];
-+};
-+
-+struct hdspm_mixer_ioctl {
-+	struct hdspm_mixer *mixer;
-+};
-+
-+/* use indirect access due to the limit of ioctl bit size */
-+#define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl)
-+
-+/* typedefs for compatibility to user-space */
-+typedef struct hdspm_peak_rms hdspm_peak_rms_t;
-+typedef struct hdspm_config_info hdspm_config_info_t;
-+typedef struct hdspm_version hdspm_version_t;
-+typedef struct hdspm_channelfader snd_hdspm_channelfader_t;
-+typedef struct hdspm_mixer hdspm_mixer_t;
-+
-+
-+#endif
-diff --git a/include/sound/uapi/sb16_csp.h b/include/sound/uapi/sb16_csp.h
-new file mode 100644
-index 00000000..e6485148
---- /dev/null
-+++ b/include/sound/uapi/sb16_csp.h
-@@ -0,0 +1,123 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+/*
-+ *  Copyright (c) 1999 by Uros Bizjak <uros@kss-loka.si>
-+ *                        Takashi Iwai <tiwai@suse.de>
-+ *
-+ *  SB16ASP/AWE32 CSP control
-+ *
-+ *   This program is free software; you can redistribute it and/or modify 
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ *
-+ *   You should have received a copy of the GNU General Public License
-+ *   along with this program; if not, write to the Free Software
-+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
-+ *
-+ */
-+#ifndef _UAPI__SOUND_SB16_CSP_H
-+#define _UAPI__SOUND_SB16_CSP_H
-+
-+
-+/* CSP modes */
-+#define SNDRV_SB_CSP_MODE_NONE		0x00
-+#define SNDRV_SB_CSP_MODE_DSP_READ	0x01	/* Record from DSP */
-+#define SNDRV_SB_CSP_MODE_DSP_WRITE	0x02	/* Play to DSP */
-+#define SNDRV_SB_CSP_MODE_QSOUND		0x04	/* QSound */
-+
-+/* CSP load flags */
-+#define SNDRV_SB_CSP_LOAD_FROMUSER	0x01
-+#define SNDRV_SB_CSP_LOAD_INITBLOCK	0x02
-+
-+/* CSP sample width */
-+#define SNDRV_SB_CSP_SAMPLE_8BIT		0x01
-+#define SNDRV_SB_CSP_SAMPLE_16BIT		0x02
-+
-+/* CSP channels */
-+#define SNDRV_SB_CSP_MONO			0x01
-+#define SNDRV_SB_CSP_STEREO		0x02
-+
-+/* CSP rates */
-+#define SNDRV_SB_CSP_RATE_8000		0x01
-+#define SNDRV_SB_CSP_RATE_11025		0x02
-+#define SNDRV_SB_CSP_RATE_22050		0x04
-+#define SNDRV_SB_CSP_RATE_44100		0x08
-+#define SNDRV_SB_CSP_RATE_ALL		0x0f
-+
-+/* CSP running state */
-+#define SNDRV_SB_CSP_ST_IDLE		0x00
-+#define SNDRV_SB_CSP_ST_LOADED		0x01
-+#define SNDRV_SB_CSP_ST_RUNNING		0x02
-+#define SNDRV_SB_CSP_ST_PAUSED		0x04
-+#define SNDRV_SB_CSP_ST_AUTO		0x08
-+#define SNDRV_SB_CSP_ST_QSOUND		0x10
-+
-+/* maximum QSound value (180 degrees right) */
-+#define SNDRV_SB_CSP_QSOUND_MAX_RIGHT	0x20
-+
-+/* maximum microcode RIFF file size */
-+#define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE	0x3000
-+
-+/* microcode header */
-+struct snd_sb_csp_mc_header {
-+	char codec_name[16];		/* id name of codec */
-+	unsigned short func_req;	/* requested function */
-+};
-+
-+/* microcode to be loaded */
-+struct snd_sb_csp_microcode {
-+	struct snd_sb_csp_mc_header info;
-+	unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE];
-+};
-+
-+/* start CSP with sample_width in mono/stereo */
-+struct snd_sb_csp_start {
-+	int sample_width;	/* sample width, look above */
-+	int channels;		/* channels, look above */
-+};
-+
-+/* CSP information */
-+struct snd_sb_csp_info {
-+	char codec_name[16];		/* id name of codec */
-+	unsigned short func_nr;		/* function number */
-+	unsigned int acc_format;	/* accepted PCM formats */
-+	unsigned short acc_channels;	/* accepted channels */
-+	unsigned short acc_width;	/* accepted sample width */
-+	unsigned short acc_rates;	/* accepted sample rates */
-+	unsigned short csp_mode;	/* CSP mode, see above */
-+	unsigned short run_channels;	/* current channels  */
-+	unsigned short run_width;	/* current sample width */
-+	unsigned short version;		/* version id: 0x10 - 0x1f */
-+	unsigned short state;		/* state bits */
-+};
-+
-+/* HWDEP controls */
-+/* get CSP information */
-+#define SNDRV_SB_CSP_IOCTL_INFO		_IOR('H', 0x10, struct snd_sb_csp_info)
-+/* load microcode to CSP */
-+/* NOTE: struct snd_sb_csp_microcode overflows the max size (13 bits)
-+ * defined for some architectures like MIPS, and it leads to build errors.
-+ * (x86 and co have 14-bit size, thus it's valid, though.)
-+ * As a workaround for skipping the size-limit check, here we don't use the
-+ * normal _IOW() macro but _IOC() with the manual argument.
-+ */
-+#define SNDRV_SB_CSP_IOCTL_LOAD_CODE	\
-+	_IOC(_IOC_WRITE, 'H', 0x11, sizeof(struct snd_sb_csp_microcode))
-+/* unload microcode from CSP */
-+#define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE	_IO('H', 0x12)
-+/* start CSP */
-+#define SNDRV_SB_CSP_IOCTL_START		_IOW('H', 0x13, struct snd_sb_csp_start)
-+/* stop CSP */
-+#define SNDRV_SB_CSP_IOCTL_STOP		_IO('H', 0x14)
-+/* pause CSP and DMA transfer */
-+#define SNDRV_SB_CSP_IOCTL_PAUSE		_IO('H', 0x15)
-+/* restart CSP and DMA transfer */
-+#define SNDRV_SB_CSP_IOCTL_RESTART	_IO('H', 0x16)
-+
-+
-+#endif /* _UAPI__SOUND_SB16_CSP_H */
-diff --git a/include/sound/uapi/sscape_ioctl.h b/include/sound/uapi/sscape_ioctl.h
-new file mode 100644
-index 00000000..c6653ebf
---- /dev/null
-+++ b/include/sound/uapi/sscape_ioctl.h
-@@ -0,0 +1,21 @@
-+#ifndef SSCAPE_IOCTL_H
-+#define SSCAPE_IOCTL_H
-+
-+
-+struct sscape_bootblock
-+{
-+  unsigned char code[256];
-+  unsigned version;
-+};
-+
-+#define SSCAPE_MICROCODE_SIZE  65536
-+
-+struct sscape_microcode
-+{
-+  unsigned char *code;
-+};
-+
-+#define SND_SSCAPE_LOAD_BOOTB  _IOWR('P', 100, struct sscape_bootblock)
-+#define SND_SSCAPE_LOAD_MCODE  _IOW ('P', 101, struct sscape_microcode)
-+
-+#endif
-diff --git a/include/sound/uapi/tlv.h b/include/sound/uapi/tlv.h
-new file mode 100644
-index 00000000..7d6d65f6
---- /dev/null
-+++ b/include/sound/uapi/tlv.h
-@@ -0,0 +1,117 @@
-+/* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note */
-+/*
-+ *   This program is free software; you can redistribute it and/or modify
-+ *   it under the terms of the GNU General Public License as published by
-+ *   the Free Software Foundation; either version 2 of the License, or
-+ *   (at your option) any later version.
-+ *
-+ *   This program is distributed in the hope that it will be useful,
-+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+ *   GNU General Public License for more details.
-+ */
-+
-+#ifndef __UAPI_SOUND_TLV_H
-+#define __UAPI_SOUND_TLV_H
-+
-+#define SNDRV_CTL_TLVT_CONTAINER 0	/* one level down - group of TLVs */
-+#define SNDRV_CTL_TLVT_DB_SCALE	1       /* dB scale */
-+#define SNDRV_CTL_TLVT_DB_LINEAR 2	/* linear volume */
-+#define SNDRV_CTL_TLVT_DB_RANGE 3	/* dB range container */
-+#define SNDRV_CTL_TLVT_DB_MINMAX 4	/* dB scale with min/max */
-+#define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5	/* dB scale with min/max with mute */
-+
-+/*
-+ * channel-mapping TLV items
-+ *  TLV length must match with num_channels
-+ */
-+#define SNDRV_CTL_TLVT_CHMAP_FIXED	0x101	/* fixed channel position */
-+#define SNDRV_CTL_TLVT_CHMAP_VAR	0x102	/* channels freely swappable */
-+#define SNDRV_CTL_TLVT_CHMAP_PAIRED	0x103	/* pair-wise swappable */
-+
-+/*
-+ * TLV structure is right behind the struct snd_ctl_tlv:
-+ *   unsigned int type  	- see SNDRV_CTL_TLVT_*
-+ *   unsigned int length
-+ *   .... data aligned to sizeof(unsigned int), use
-+ *        block_length = (length + (sizeof(unsigned int) - 1)) &
-+ *                       ~(sizeof(unsigned int) - 1)) ....
-+ */
-+#define SNDRV_CTL_TLVD_ITEM(type, ...) \
-+	(type), SNDRV_CTL_TLVD_LENGTH(__VA_ARGS__), __VA_ARGS__
-+#define SNDRV_CTL_TLVD_LENGTH(...) \
-+	((unsigned int)sizeof((const unsigned int[]) { __VA_ARGS__ }))
-+
-+/* Accessor offsets for TLV data items */
-+#define SNDRV_CTL_TLVO_TYPE		0
-+#define SNDRV_CTL_TLVO_LEN		1
-+
-+#define SNDRV_CTL_TLVD_CONTAINER_ITEM(...) \
-+	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_CONTAINER, __VA_ARGS__)
-+#define SNDRV_CTL_TLVD_DECLARE_CONTAINER(name, ...) \
-+	unsigned int name[] = { \
-+		SNDRV_CTL_TLVD_CONTAINER_ITEM(__VA_ARGS__) \
-+	}
-+
-+#define SNDRV_CTL_TLVD_DB_SCALE_MASK	0xffff
-+#define SNDRV_CTL_TLVD_DB_SCALE_MUTE	0x10000
-+#define SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \
-+	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_SCALE, \
-+			    (min), \
-+			    ((step) & SNDRV_CTL_TLVD_DB_SCALE_MASK) | \
-+			     ((mute) ? SNDRV_CTL_TLVD_DB_SCALE_MUTE : 0))
-+#define SNDRV_CTL_TLVD_DECLARE_DB_SCALE(name, min, step, mute) \
-+	unsigned int name[] = { \
-+		SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \
-+	}
-+
-+/* Accessor offsets for min, mute and step items in dB scale type TLV */
-+#define SNDRV_CTL_TLVO_DB_SCALE_MIN		2
-+#define SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP	3
-+
-+/* dB scale specified with min/max values instead of step */
-+#define SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \
-+	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX, (min_dB), (max_dB))
-+#define SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \
-+	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX_MUTE, (min_dB), (max_dB))
-+#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(name, min_dB, max_dB) \
-+	unsigned int name[] = { \
-+		SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \
-+	}
-+#define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE(name, min_dB, max_dB) \
-+	unsigned int name[] = { \
-+		SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \
-+	}
-+
-+/* Accessor offsets for min, max items in db-minmax types of TLV. */
-+#define SNDRV_CTL_TLVO_DB_MINMAX_MIN	2
-+#define SNDRV_CTL_TLVO_DB_MINMAX_MAX	3
-+
-+/* linear volume between min_dB and max_dB (.01dB unit) */
-+#define SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \
-+	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_LINEAR, (min_dB), (max_dB))
-+#define SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(name, min_dB, max_dB) \
-+	unsigned int name[] = { \
-+		SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \
-+	}
-+
-+/* Accessor offsets for min, max items in db-linear type of TLV. */
-+#define SNDRV_CTL_TLVO_DB_LINEAR_MIN	2
-+#define SNDRV_CTL_TLVO_DB_LINEAR_MAX	3
-+
-+/* dB range container:
-+ * Items in dB range container must be ordered by their values and by their
-+ * dB values. This implies that larger values must correspond with larger
-+ * dB values (which is also required for all other mixer controls).
-+ */
-+/* Each item is: <min> <max> <TLV> */
-+#define SNDRV_CTL_TLVD_DB_RANGE_ITEM(...) \
-+	SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_RANGE, __VA_ARGS__)
-+#define SNDRV_CTL_TLVD_DECLARE_DB_RANGE(name, ...) \
-+	unsigned int name[] = { \
-+		SNDRV_CTL_TLVD_DB_RANGE_ITEM(__VA_ARGS__) \
-+	}
-+
-+#define SNDRV_CTL_TLVD_DB_GAIN_MUTE	-9999999
-+
-+#endif
-diff --git a/src/topology/tplg_local.h b/src/topology/tplg_local.h
-index 11efce6d..101491a4 100644
---- a/src/topology/tplg_local.h
-+++ b/src/topology/tplg_local.h
-@@ -18,8 +18,7 @@
- #include "list.h"
- #include "topology.h"
- 
--#define __packed __attribute__((__packed__))
--
-+#include <sound/type_compat.h>
- #include <sound/asound.h>
- #include <sound/asoc.h>
- #include <sound/tlv.h>
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-configure.ac-remove-an-unnecessary-libtool-fix.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-configure.ac-remove-an-unnecessary-libtool-fix.patch
deleted file mode 100644
index 4db4934..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-configure.ac-remove-an-unnecessary-libtool-fix.patch
+++ /dev/null
@@ -1,50 +0,0 @@
-From 01cd8cb6d594d7a12c67d21d689ebe0e347469c0 Mon Sep 17 00:00:00 2001
-From: Tanu Kaskinen <tanuk@iki.fi>
-Date: Fri, 20 Dec 2019 09:26:12 +0200
-Subject: [PATCH] configure.ac: remove an unnecessary libtool fix
-
-This code was added in commit 75d393a563efb578c79364a277087c6326267f52
-without explaining why. I assume it was a mistake, since it looks like
-the libtool problem should have gone away a long time ago. The referenced
-wiki page https://wiki.debian.org/RpathIssue says:
-
-    Since libtool 1.5.2 (released 2004-01-25), on Linux libtool no
-    longer sets RPATH for any directories in the dynamic linker search
-    path, so this should no longer be an issue unless upstream used a
-    really old version of libtool when creating their distribution
-    tarball.
-
-This code caused problems in OpenEmbedded, where the libtool script is
-named "x86_64-oe-linux-libtool" or similar rather than just "libtool",
-so the sed command failed with a file not found error. Rather than
-adapting the code to OpenEmbedded's peculiarities, it seems best to just
-remove the unnecessary code altogether.
-
-Upstream-Status: Submitted [https://github.com/alsa-project/alsa-lib/pull/19]
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- configure.ac | 11 -----------
- 1 file changed, 11 deletions(-)
-
-diff --git a/configure.ac b/configure.ac
-index 119ef600..22a4a885 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -764,14 +764,3 @@ test "$build_seq" = "yes" && echo "#include <alsa/seq.h>" >> include/asoundlib.h
- test "$build_seq" = "yes" && echo "#include <alsa/seqmid.h>" >> include/asoundlib.h
- test "$build_seq" = "yes" && echo "#include <alsa/seq_midi_event.h>" >> include/asoundlib.h
- cat "$srcdir"/include/asoundlib-tail.h >> include/asoundlib.h
--
--dnl Taken from https://wiki.debian.org/RpathIssue
--case $host in
--   *-*-linux-gnu)
--   AC_MSG_RESULT([Fixing libtool for -rpath problems.])
--   sed < libtool > libtool-2 \
--     's/^hardcode_libdir_flag_spec.*$'/'hardcode_libdir_flag_spec=" -D__LIBTOOL_IS_A_FOOL__ "/'
--   mv libtool-2 libtool
--   chmod 755 libtool
-- ;;
--esac
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-uapi-Move-typedefs-from-uapi-to-sound.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-uapi-Move-typedefs-from-uapi-to-sound.patch
deleted file mode 100644
index c35a2c9..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-uapi-Move-typedefs-from-uapi-to-sound.patch
+++ /dev/null
@@ -1,137 +0,0 @@
-From 59792f467b38d6a4c4dffdb30528f7fb03d23d96 Mon Sep 17 00:00:00 2001
-From: Takashi Iwai <tiwai@suse.de>
-Date: Fri, 20 Dec 2019 17:12:37 +0100
-Subject: [PATCH] uapi: Move typedefs from uapi to sound/*
-
-For keeping uapi/*.h cleaner.
-
-Signed-off-by: Takashi Iwai <tiwai@suse.de>
-
-Upstream-Status: Backport
-
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- include/sound/emu10k1.h      |  9 +++++++++
- include/sound/hdsp.h         | 10 ++++++++++
- include/sound/hdspm.h        |  8 ++++++++
- include/sound/sb16_csp.h     |  4 ++++
- include/sound/uapi/emu10k1.h | 10 ----------
- include/sound/uapi/hdsp.h    |  9 ---------
- include/sound/uapi/hdspm.h   |  8 --------
- 7 files changed, 31 insertions(+), 27 deletions(-)
-
-diff --git a/include/sound/emu10k1.h b/include/sound/emu10k1.h
-index f06ecee5..0832f95b 100644
---- a/include/sound/emu10k1.h
-+++ b/include/sound/emu10k1.h
-@@ -1,2 +1,11 @@
- #include <alsa/sound/type_compat.h>
- #include <alsa/sound/uapi/emu10k1.h>
-+#ifndef __emu10k1_type_defined
-+#define __emu10k1_type_defined
-+typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t;
-+typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t;
-+typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t;
-+typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t;
-+typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t;
-+typedef struct emu10k1_ctl_elem_id emu10k1_ctl_elem_id_t;
-+#endif
-diff --git a/include/sound/hdsp.h b/include/sound/hdsp.h
-index 78fb745b..e8f93156 100644
---- a/include/sound/hdsp.h
-+++ b/include/sound/hdsp.h
-@@ -1,2 +1,12 @@
- #include <alsa/sound/type_compat.h>
- #include <alsa/sound/uapi/hdsp.h>
-+#ifndef __hdsp_type_defined
-+#define __hdsp_type_defined
-+typedef enum HDSP_IO_Type HDSP_IO_Type;
-+typedef struct hdsp_peak_rms hdsp_peak_rms_t;
-+typedef struct hdsp_config_info hdsp_config_info_t;
-+typedef struct hdsp_firmware hdsp_firmware_t;
-+typedef struct hdsp_version hdsp_version_t;
-+typedef struct hdsp_mixer hdsp_mixer_t;
-+typedef struct hdsp_9632_aeb hdsp_9632_aeb_t;
-+#endif
-diff --git a/include/sound/hdspm.h b/include/sound/hdspm.h
-index af6d19ed..d9095d9f 100644
---- a/include/sound/hdspm.h
-+++ b/include/sound/hdspm.h
-@@ -1,2 +1,10 @@
- #include <alsa/sound/type_compat.h>
- #include <alsa/sound/uapi/hdspm.h>
-+#ifndef __hdspm_type_defined
-+#define __hdspm_type_defined
-+typedef struct hdspm_peak_rms hdspm_peak_rms_t;
-+typedef struct hdspm_config_info hdspm_config_info_t;
-+typedef struct hdspm_version hdspm_version_t;
-+typedef struct hdspm_channelfader snd_hdspm_channelfader_t;
-+typedef struct hdspm_mixer hdspm_mixer_t;
-+#endif
-diff --git a/include/sound/sb16_csp.h b/include/sound/sb16_csp.h
-index 24121fcb..fd02bc56 100644
---- a/include/sound/sb16_csp.h
-+++ b/include/sound/sb16_csp.h
-@@ -1 +1,5 @@
- #include <alsa/sound/uapi/sb16_csp.h>
-+#ifndef __sb16_csp_type_defined
-+#define __sb16_csp_type_defined
-+typedef struct snd_sb_csp_microcode snd_sb_csp_microcode_t;
-+#endif
-diff --git a/include/sound/uapi/emu10k1.h b/include/sound/uapi/emu10k1.h
-index c1150e4d..6bcd76f6 100644
---- a/include/sound/uapi/emu10k1.h
-+++ b/include/sound/uapi/emu10k1.h
-@@ -382,14 +382,4 @@ struct snd_emu10k1_fx8010_pcm_rec {
- #define SNDRV_EMU10K1_IOCTL_SINGLE_STEP	_IOW ('H', 0x83, int)
- #define SNDRV_EMU10K1_IOCTL_DBG_READ	_IOR ('H', 0x84, int)
- 
--#ifndef __KERNEL__
--/* typedefs for compatibility to user-space */
--typedef struct snd_emu10k1_fx8010_info emu10k1_fx8010_info_t;
--typedef struct snd_emu10k1_fx8010_control_gpr emu10k1_fx8010_control_gpr_t;
--typedef struct snd_emu10k1_fx8010_code emu10k1_fx8010_code_t;
--typedef struct snd_emu10k1_fx8010_tram emu10k1_fx8010_tram_t;
--typedef struct snd_emu10k1_fx8010_pcm_rec emu10k1_fx8010_pcm_t;
--typedef struct emu10k1_ctl_elem_id emu10k1_ctl_elem_id_t;
--#endif
--
- #endif /* _UAPI__SOUND_EMU10K1_H */
-diff --git a/include/sound/uapi/hdsp.h b/include/sound/uapi/hdsp.h
-index 88c92a3f..7ac2d3f2 100644
---- a/include/sound/uapi/hdsp.h
-+++ b/include/sound/uapi/hdsp.h
-@@ -97,13 +97,4 @@ struct hdsp_9632_aeb {
- 
- #define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb)
- 
--/* typedefs for compatibility to user-space */
--typedef enum HDSP_IO_Type HDSP_IO_Type;
--typedef struct hdsp_peak_rms hdsp_peak_rms_t;
--typedef struct hdsp_config_info hdsp_config_info_t;
--typedef struct hdsp_firmware hdsp_firmware_t;
--typedef struct hdsp_version hdsp_version_t;
--typedef struct hdsp_mixer hdsp_mixer_t;
--typedef struct hdsp_9632_aeb hdsp_9632_aeb_t;
--
- #endif /* __SOUND_HDSP_H */
-diff --git a/include/sound/uapi/hdspm.h b/include/sound/uapi/hdspm.h
-index 2d91f90e..3fbfd9dc 100644
---- a/include/sound/uapi/hdspm.h
-+++ b/include/sound/uapi/hdspm.h
-@@ -219,12 +219,4 @@ struct hdspm_mixer_ioctl {
- /* use indirect access due to the limit of ioctl bit size */
- #define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl)
- 
--/* typedefs for compatibility to user-space */
--typedef struct hdspm_peak_rms hdspm_peak_rms_t;
--typedef struct hdspm_config_info hdspm_config_info_t;
--typedef struct hdspm_version hdspm_version_t;
--typedef struct hdspm_channelfader snd_hdspm_channelfader_t;
--typedef struct hdspm_mixer hdspm_mixer_t;
--
--
- #endif
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch
deleted file mode 100644
index 96dcd8a..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch
+++ /dev/null
@@ -1,41 +0,0 @@
-From 4b6fe372c68d1ff50e7c161cffadeb298734f49c Mon Sep 17 00:00:00 2001
-From: paulhsia <paulhsia@chromium.org>
-Date: Sat, 30 Nov 2019 03:35:30 +0800
-Subject: [PATCH 1/5] ucm: Use strncmp to avoid access-out-of-boundary
-
-If the length of the identifier is less than the length of the prefix,
-access-out-of-boundary will occur in memcmp().
-
-Signed-off-by: paulhsia <paulhsia@chromium.org>
-Signed-off-by: Jaroslav Kysela <perex@perex.cz>
-
-Upstream-Status: Backport
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- src/ucm/main.c | 8 +++++---
- 1 file changed, 5 insertions(+), 3 deletions(-)
-
-diff --git a/src/ucm/main.c b/src/ucm/main.c
-index b0b6ffb3..252e50d9 100644
---- a/src/ucm/main.c
-+++ b/src/ucm/main.c
-@@ -61,11 +61,13 @@ static int check_identifier(const char *identifier, const char *prefix)
- {
- 	int len;
- 
--	if (strcmp(identifier, prefix) == 0)
--		return 1;
- 	len = strlen(prefix);
--	if (memcmp(identifier, prefix, len) == 0 && identifier[len] == '/')
-+	if (strncmp(identifier, prefix, len) != 0)
-+		return 0;
-+
-+	if (identifier[len] == 0 || identifier[len] == '/')
- 		return 1;
-+
- 	return 0;
- }
- 
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch
deleted file mode 100644
index 42973fb..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch
+++ /dev/null
@@ -1,45 +0,0 @@
-From 58f9dc9bd12a51efa12dbc67e200f4d85cd3da07 Mon Sep 17 00:00:00 2001
-From: Jaroslav Kysela <perex@perex.cz>
-Date: Fri, 29 Nov 2019 22:28:26 +0100
-Subject: [PATCH 2/5] ucm: return always at least NULL if no list is available
- in snd_use_case_get_list()
-
-Signed-off-by: Jaroslav Kysela <perex@perex.cz>
-
-Upstream-Status: Backport
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- src/ucm/main.c | 8 ++++++--
- 1 file changed, 6 insertions(+), 2 deletions(-)
-
-diff --git a/src/ucm/main.c b/src/ucm/main.c
-index 252e50d9..b80db65f 100644
---- a/src/ucm/main.c
-+++ b/src/ucm/main.c
-@@ -1160,8 +1160,10 @@ static int get_supcon_device_list(snd_use_case_mgr_t *uc_mgr,
- 
- 	modifier = find_modifier(uc_mgr, verb, name, 0);
- 	if (modifier) {
--		if (modifier->dev_list.type != type)
-+		if (modifier->dev_list.type != type) {
-+			*list = NULL;
- 			return 0;
-+		}
- 		return get_list(&modifier->dev_list.list, list,
- 				struct dev_list_node, list,
- 				name);
-@@ -1169,8 +1171,10 @@ static int get_supcon_device_list(snd_use_case_mgr_t *uc_mgr,
- 
- 	device = find_device(uc_mgr, verb, name, 0);
- 	if (device) {
--		if (device->dev_list.type != type)
-+		if (device->dev_list.type != type) {
-+			*list = NULL;
- 			return 0;
-+		}
- 		return get_list(&device->dev_list.list, list,
- 				struct dev_list_node, list,
- 				name);
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0003-namehint-correct-the-args-check.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0003-namehint-correct-the-args-check.patch
deleted file mode 100644
index 82f8b2b..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0003-namehint-correct-the-args-check.patch
+++ /dev/null
@@ -1,34 +0,0 @@
-From 10f3401ce356a675e2440993457ee7c8c7e9fcf8 Mon Sep 17 00:00:00 2001
-From: Jaroslav Kysela <perex@perex.cz>
-Date: Sun, 1 Dec 2019 14:26:40 +0100
-Subject: [PATCH 3/5] namehint: correct the @args check
-
-BugLink: https://github.com/alsa-project/alsa-plugins/issues/3
-Signed-off-by: Jaroslav Kysela <perex@perex.cz>
-
-Upstream-Status: Backport
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- src/control/namehint.c | 6 ++++++
- 1 file changed, 6 insertions(+)
-
-diff --git a/src/control/namehint.c b/src/control/namehint.c
-index 808df6b5..4927ef97 100644
---- a/src/control/namehint.c
-+++ b/src/control/namehint.c
-@@ -348,6 +348,12 @@ static int try_config(snd_config_t *config,
- 		goto __cleanup;
- 	if (snd_config_search(res, "@args", &cfg) >= 0) {
- 		snd_config_for_each(i, next, cfg) {
-+			/* skip the argument list */
-+			snd_config_get_id(snd_config_iterator_entry(i), &str);
-+			while (*str && *str >= '0' && *str <= '9') str++;
-+			if (*str == '\0')
-+				continue;
-+			/* the argument definition must have the default */
- 			if (snd_config_search(snd_config_iterator_entry(i),
- 					      "default", NULL) < 0) {
- 				err = -EINVAL;
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0004-namehint-improve-the-previous-patch-check-the-return.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0004-namehint-improve-the-previous-patch-check-the-return.patch
deleted file mode 100644
index 98192f6..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0004-namehint-improve-the-previous-patch-check-the-return.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-From 1fa6664d5f0cc7d21edceba6695a4c28543c2cab Mon Sep 17 00:00:00 2001
-From: Jaroslav Kysela <perex@perex.cz>
-Date: Sun, 1 Dec 2019 14:30:54 +0100
-Subject: [PATCH 4/5] namehint: improve the previous patch (check the returned
- value)
-
-Signed-off-by: Jaroslav Kysela <perex@perex.cz>
-
-Upstream-Status: Backport
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- src/control/namehint.c | 3 ++-
- 1 file changed, 2 insertions(+), 1 deletion(-)
-
-diff --git a/src/control/namehint.c b/src/control/namehint.c
-index 4927ef97..60c48ae3 100644
---- a/src/control/namehint.c
-+++ b/src/control/namehint.c
-@@ -349,7 +349,8 @@ static int try_config(snd_config_t *config,
- 	if (snd_config_search(res, "@args", &cfg) >= 0) {
- 		snd_config_for_each(i, next, cfg) {
- 			/* skip the argument list */
--			snd_config_get_id(snd_config_iterator_entry(i), &str);
-+			if (snd_config_get_id(snd_config_iterator_entry(i), &str) < 0)
-+				continue;
- 			while (*str && *str >= '0' && *str <= '9') str++;
- 			if (*str == '\0')
- 				continue;
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib/0005-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch b/poky/meta/recipes-multimedia/alsa/alsa-lib/0005-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch
deleted file mode 100644
index cbc0a4c..0000000
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib/0005-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch
+++ /dev/null
@@ -1,86 +0,0 @@
-From 976f8f62238f0d837584adc7c31035bdb29b6d6f Mon Sep 17 00:00:00 2001
-From: Hans de Goede <hdegoede@redhat.com>
-Date: Tue, 3 Dec 2019 18:27:39 +0100
-Subject: [PATCH 5/5] ucm: Do not fail to parse configs on cards with an empty
- CardComponents lists
-
-Since the UCM profiles for all Bay- and Cherry-Trail SST cards have been
-moved over to UCM2, parsing them fails with:
-
-ALSA lib ucm_subs.c:220:(uc_mgr_get_substituted_value) variable '${CardComponents}' is not defined in this context!
-
-This completely breaks audio support on all Bay- and Cherry-Trail devices.
-
-This is caused by these non-SOF ASoC using cards having an empty
-CardComponents list. Which in itself is fine, but is rejected by
-the ucm_subs.c code. This commit changes the ucm_subs code to accept
-an empty string as a valid value for CardComponents restoring audio
-functionality on these boards.
-
-Signed-off-by: Hans de Goede <hdegoede@redhat.com>
-Signed-off-by: Jaroslav Kysela <perex@perex.cz>
-
-Upstream-Status: Backport
-Signed-off-by: Tanu Kaskinen <tanuk@iki.fi>
----
- src/ucm/ucm_subs.c | 20 ++++++++++++--------
- 1 file changed, 12 insertions(+), 8 deletions(-)
-
-diff --git a/src/ucm/ucm_subs.c b/src/ucm/ucm_subs.c
-index 00afa9e3..90e395f0 100644
---- a/src/ucm/ucm_subs.c
-+++ b/src/ucm/ucm_subs.c
-@@ -25,6 +25,7 @@
-  */
- 
- #include "ucm_local.h"
-+#include <stdbool.h>
- #include <sys/stat.h>
- #include <limits.h>
- 
-@@ -145,10 +146,11 @@ static char *rval_sysfs(snd_use_case_mgr_t *uc_mgr ATTRIBUTE_UNUSED, const char
- 	return strdup(path);
- }
- 
--#define MATCH_VARIABLE(name, id, fcn)					\
-+#define MATCH_VARIABLE(name, id, fcn, empty_ok)				\
- 	if (strncmp((name), (id), sizeof(id) - 1) == 0) { 		\
- 		rval = fcn(uc_mgr);					\
- 		idsize = sizeof(id) - 1;				\
-+		allow_empty = (empty_ok);				\
- 		goto __rval;						\
- 	}
- 
-@@ -189,12 +191,14 @@ int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr,
- 
- 	while (*value) {
- 		if (*value == '$' && *(value+1) == '{') {
--			MATCH_VARIABLE(value, "${ConfName}", rval_conf_name);
--			MATCH_VARIABLE(value, "${CardId}", rval_card_id);
--			MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver);
--			MATCH_VARIABLE(value, "${CardName}", rval_card_name);
--			MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname);
--			MATCH_VARIABLE(value, "${CardComponents}", rval_card_components);
-+			bool allow_empty = false;
-+
-+			MATCH_VARIABLE(value, "${ConfName}", rval_conf_name, false);
-+			MATCH_VARIABLE(value, "${CardId}", rval_card_id, false);
-+			MATCH_VARIABLE(value, "${CardDriver}", rval_card_driver, false);
-+			MATCH_VARIABLE(value, "${CardName}", rval_card_name, false);
-+			MATCH_VARIABLE(value, "${CardLongName}", rval_card_longname, false);
-+			MATCH_VARIABLE(value, "${CardComponents}", rval_card_components, true);
- 			MATCH_VARIABLE2(value, "${env:", rval_env);
- 			MATCH_VARIABLE2(value, "${sys:", rval_sysfs);
- 			err = -EINVAL;
-@@ -208,7 +212,7 @@ int uc_mgr_get_substituted_value(snd_use_case_mgr_t *uc_mgr,
- 			}
- 			goto __error;
- __rval:
--			if (rval == NULL || rval[0] == '\0') {
-+			if (rval == NULL || (!allow_empty && rval[0] == '\0')) {
- 				free(rval);
- 				strncpy(r, value, idsize);
- 				r[idsize] = '\0';
--- 
-2.20.1
-
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-lib_1.2.1.2.bb b/poky/meta/recipes-multimedia/alsa/alsa-lib_1.2.2.bb
similarity index 62%
rename from poky/meta/recipes-multimedia/alsa/alsa-lib_1.2.1.2.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-lib_1.2.2.bb
index e2bc61f..9a4082f 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-lib_1.2.1.2.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-lib_1.2.2.bb
@@ -7,18 +7,9 @@
                     file://src/socket.c;md5=285675b45e83f571c6a957fe4ab79c93;beginline=9;endline=24 \
                     "
 
-SRC_URI = "https://www.alsa-project.org/files/pub/lib/${BP}.tar.bz2 \
-           file://0001-configure.ac-remove-an-unnecessary-libtool-fix.patch \
-           file://0001-ucm-Use-strncmp-to-avoid-access-out-of-boundary.patch \
-           file://0002-ucm-return-always-at-least-NULL-if-no-list-is-availa.patch \
-           file://0003-namehint-correct-the-args-check.patch \
-           file://0004-namehint-improve-the-previous-patch-check-the-return.patch \
-           file://0005-ucm-Do-not-fail-to-parse-configs-on-cards-with-an-em.patch \
-           file://0001-Fix-alsa-sound-.h-for-external-programs.patch \
-           file://0001-uapi-Move-typedefs-from-uapi-to-sound.patch \
-           "
-SRC_URI[md5sum] = "82ddd3698469beec147e4f4a67134ea0"
-SRC_URI[sha256sum] = "958e260e3673f1f6ff6b2d2c0df3fc2e469bea5b2957163ce96ce17f23e87943"
+SRC_URI = "https://www.alsa-project.org/files/pub/lib/${BP}.tar.bz2"
+SRC_URI[md5sum] = "82cdc23a5233d5ed319d2cbc89af5ca5"
+SRC_URI[sha256sum] = "d8e853d8805574777bbe40937812ad1419c9ea7210e176f0def3e6ed255ab3ec"
 
 inherit autotools pkgconfig
 
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-plugins_1.2.1.bb b/poky/meta/recipes-multimedia/alsa/alsa-plugins_1.2.2.bb
similarity index 93%
rename from poky/meta/recipes-multimedia/alsa/alsa-plugins_1.2.1.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-plugins_1.2.2.bb
index d092b15..52dee30 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-plugins_1.2.1.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-plugins_1.2.2.bb
@@ -13,16 +13,15 @@
 # license for libsamplerate, the samplerate plugin may be used under the terms
 # of LGPLv2.1 like the rest of the plugins.
 LICENSE = "LGPLv2.1 & GPLv2+"
-LIC_FILES_CHKSUM = "\
-        file://COPYING;md5=a916467b91076e631dd8edb7424769c7 \
-        file://COPYING.GPL;md5=59530bdf33659b29e73d4adb9f9f6552 \
-        file://m4/attributes.m4;endline=33;md5=b25958da44c02231e3641f1bccef53eb \
-        file://rate/rate_samplerate.c;endline=35;md5=fd77bce85f4a338c0e8ab18430b69fae \
-"
+LIC_FILES_CHKSUM = "file://COPYING;md5=a916467b91076e631dd8edb7424769c7 \
+                    file://COPYING.GPL;md5=59530bdf33659b29e73d4adb9f9f6552 \
+                    file://m4/attributes.m4;endline=33;md5=bb8c6b2a67ac15156961e242fec33e50 \
+                    file://rate/rate_samplerate.c;endline=35;md5=fd77bce85f4a338c0e8ab18430b69fae \
+                    "
 
 SRC_URI = "https://www.alsa-project.org/files/pub/plugins/${BP}.tar.bz2"
-SRC_URI[md5sum] = "5b11cd3ec92e5f9190ec378565b529e8"
-SRC_URI[sha256sum] = "4d94de7ad41734b8604a652521200bb6554fcf0c2c00fdbd302b1710d76548da"
+SRC_URI[md5sum] = "8455e3c6fbc47f62f070afabc14ba575"
+SRC_URI[sha256sum] = "1c0f06450c928d711719686c9dbece2d480184f36fab11b8f0534cb7b41e337d"
 
 DEPENDS += "alsa-lib"
 
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-tools_1.1.7.bb b/poky/meta/recipes-multimedia/alsa/alsa-tools_1.2.2.bb
similarity index 95%
rename from poky/meta/recipes-multimedia/alsa/alsa-tools_1.1.7.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-tools_1.2.2.bb
index c1f4acd..0838be8 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-tools_1.1.7.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-tools_1.2.2.bb
@@ -11,8 +11,8 @@
 
 SRC_URI = "https://www.alsa-project.org/files/pub/tools/${BP}.tar.bz2"
 
-SRC_URI[md5sum] = "475bdf6457bcf55c8c895d653ee56a54"
-SRC_URI[sha256sum] = "a0243328a8f6f691a3055c484fd8d3326393096325e93743b246029d327c4ef6"
+SRC_URI[md5sum] = "4e6187d2c3a8c73a9d75d66a72faed27"
+SRC_URI[sha256sum] = "bfd3c7aae1289269605d3da02279159b10e3dabdd31e658cbceaa30170957349"
 
 inherit autotools-brokensep pkgconfig
 # brokensep as as10k1 (and probably more) fail out of tree
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-topology-conf_1.2.1.bb b/poky/meta/recipes-multimedia/alsa/alsa-topology-conf_1.2.2.bb
similarity index 61%
rename from poky/meta/recipes-multimedia/alsa/alsa-topology-conf_1.2.1.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-topology-conf_1.2.2.bb
index add1f30..2901794 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-topology-conf_1.2.1.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-topology-conf_1.2.2.bb
@@ -4,11 +4,8 @@
 LICENSE = "BSD-3-Clause"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=20d74d74db9741697903372ad001d3b4"
 
-# The tarball doesn't have any toplevel directory. The subdir option tells
-# Bitbake to unpack the archive to the correct place.
-SRC_URI = "https://www.alsa-project.org/files/pub/lib/${BP}.tar.bz2;subdir=${BP}"
-SRC_URI[md5sum] = "7fdf5fff3f1e0603456e719f6033e922"
-SRC_URI[sha256sum] = "354a43f4031c98bef1349ac722d83b2603ef439f81a1ab1eba8814c28243a9b2"
+SRC_URI = "https://www.alsa-project.org/files/pub/lib/${BP}.tar.bz2"
+SRC_URI[sha256sum] = "b472d6b567c78173bd69543d9cffc9e379c80eb763c3afc8d5b24d5610d19425"
 
 inherit allarch
 
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-ucm-conf_1.2.1.2.bb b/poky/meta/recipes-multimedia/alsa/alsa-ucm-conf_1.2.2.bb
similarity index 63%
rename from poky/meta/recipes-multimedia/alsa/alsa-ucm-conf_1.2.1.2.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-ucm-conf_1.2.2.bb
index 469d1f7..1a524d4 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-ucm-conf_1.2.1.2.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-ucm-conf_1.2.2.bb
@@ -4,11 +4,8 @@
 LICENSE = "BSD-3-Clause"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=20d74d74db9741697903372ad001d3b4"
 
-# The tarball doesn't have any toplevel directory. The subdir option tells
-# Bitbake to unpack the archive to the correct place.
-SRC_URI = "https://www.alsa-project.org/files/pub/lib/${BP}.tar.bz2;subdir=${BP}"
-SRC_URI[md5sum] = "b7fa43cfd79df978184a6333766d2a50"
-SRC_URI[sha256sum] = "ea8a86875f4cf430d49a662a04a6d6c606c5c9d67e54cb944c4d77b24554062f"
+SRC_URI = "https://www.alsa-project.org/files/pub/lib/${BP}.tar.bz2"
+SRC_URI[sha256sum] = "7ebfd929bc85a51f16fa3c8c4db13faa2ea6ff2b2266fc36d6198bdafe73c40c"
 
 inherit allarch
 
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-utils-scripts_1.2.1.bb b/poky/meta/recipes-multimedia/alsa/alsa-utils-scripts_1.2.2.bb
similarity index 95%
rename from poky/meta/recipes-multimedia/alsa/alsa-utils-scripts_1.2.1.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-utils-scripts_1.2.2.bb
index fef79d9..048fef6 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-utils-scripts_1.2.1.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-utils-scripts_1.2.2.bb
@@ -1,4 +1,4 @@
-require alsa-utils_${PV}.bb
+require alsa-utils.inc
 
 SUMMARY = "Shell scripts that show help info and create ALSA configuration files"
 PROVIDES = "alsa-utils-alsaconf"
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-utils_1.2.1.bb b/poky/meta/recipes-multimedia/alsa/alsa-utils.inc
similarity index 96%
rename from poky/meta/recipes-multimedia/alsa/alsa-utils_1.2.1.bb
rename to poky/meta/recipes-multimedia/alsa/alsa-utils.inc
index 9144af6..8bbc5d3 100644
--- a/poky/meta/recipes-multimedia/alsa/alsa-utils_1.2.1.bb
+++ b/poky/meta/recipes-multimedia/alsa/alsa-utils.inc
@@ -21,8 +21,8 @@
 
 # alsa-utils specified in SRC_URI due to alsa-utils-scripts recipe
 SRC_URI = "https://www.alsa-project.org/files/pub/utils/alsa-utils-${PV}.tar.bz2"
-SRC_URI[md5sum] = "c4628bae7632937eac2de4cf2a3de82e"
-SRC_URI[sha256sum] = "0b110ba71ef41d3009db1bc4dcae0cf79efb99cb5426fa19d0312470560a2c0d"
+SRC_URI[md5sum] = "00612234ff4722c8f7f8f7a83ff9bc63"
+SRC_URI[sha256sum] = "44807bd578c5f6df6e91a11b8d37e546424a5a1ea8d8e659ee359fe01730e4f3"
 
 # On build machines with python-docutils (not python3-docutils !!) installed
 # rst2man (not rst2man.py) is detected and compile fails with
diff --git a/poky/meta/recipes-multimedia/alsa/alsa-utils_1.2.2.bb b/poky/meta/recipes-multimedia/alsa/alsa-utils_1.2.2.bb
new file mode 100644
index 0000000..ff8945e
--- /dev/null
+++ b/poky/meta/recipes-multimedia/alsa/alsa-utils_1.2.2.bb
@@ -0,0 +1 @@
+require alsa-utils.inc
diff --git a/poky/meta/recipes-multimedia/libtiff/tiff_4.1.0.bb b/poky/meta/recipes-multimedia/libtiff/tiff_4.1.0.bb
index 1f92c18..9b907fb 100644
--- a/poky/meta/recipes-multimedia/libtiff/tiff_4.1.0.bb
+++ b/poky/meta/recipes-multimedia/libtiff/tiff_4.1.0.bb
@@ -47,4 +47,4 @@
     oe_multilib_header tiffconf.h
 }
 
-BBCLASSEXTEND = "native"
+BBCLASSEXTEND = "native nativesdk"
diff --git a/poky/meta/recipes-multimedia/mpg123/mpg123_1.25.13.bb b/poky/meta/recipes-multimedia/mpg123/mpg123_1.25.13.bb
index 125574f..6c7b6fa 100644
--- a/poky/meta/recipes-multimedia/mpg123/mpg123_1.25.13.bb
+++ b/poky/meta/recipes-multimedia/mpg123/mpg123_1.25.13.bb
@@ -14,6 +14,8 @@
 SRC_URI[md5sum] = "294a6c30546504ec3d0deac2b2ea22be"
 SRC_URI[sha256sum] = "90306848359c793fd43b9906e52201df18775742dc3c81c06ab67a806509890a"
 
+UPSTREAM_CHECK_REGEX = "mpg123-(?P<pver>\d+(\.\d+)+)\.tar"
+
 inherit autotools pkgconfig
 
 # The options should be mutually exclusive for configuration script.
diff --git a/poky/meta/recipes-multimedia/pulseaudio/pulseaudio_13.0.bb b/poky/meta/recipes-multimedia/pulseaudio/pulseaudio_13.0.bb
index 601499b..b7a4a9b 100644
--- a/poky/meta/recipes-multimedia/pulseaudio/pulseaudio_13.0.bb
+++ b/poky/meta/recipes-multimedia/pulseaudio/pulseaudio_13.0.bb
@@ -8,6 +8,7 @@
            "
 SRC_URI[md5sum] = "e41d606f90254ed45c90520faf83d95c"
 SRC_URI[sha256sum] = "961b23ca1acfd28f2bc87414c27bb40e12436efcf2158d29721b1e89f3f28057"
+UPSTREAM_CHECK_REGEX = "pulseaudio-(?P<pver>\d+(\.(?!99)\d+)+)\.tar"
 
 do_compile_prepend() {
     mkdir -p ${S}/libltdl
diff --git a/poky/meta/recipes-multimedia/x264/x264_git.bb b/poky/meta/recipes-multimedia/x264/x264_git.bb
index 39429a8..1ff5348 100644
--- a/poky/meta/recipes-multimedia/x264/x264_git.bb
+++ b/poky/meta/recipes-multimedia/x264/x264_git.bb
@@ -14,7 +14,7 @@
            "
 UPSTREAM_CHECK_COMMITS = "1"
 
-SRCREV = "1771b556ee45207f8711744ccbd5d42a3949b14c"
+SRCREV = "296494a4011f58f32adc54304a2654627558c59a"
 
 PV = "r2991+git${SRCPV}"
 
diff --git a/poky/meta/recipes-sato/puzzles/puzzles_git.bb b/poky/meta/recipes-sato/puzzles/puzzles_git.bb
index 41b78d6..1e53051 100644
--- a/poky/meta/recipes-sato/puzzles/puzzles_git.bb
+++ b/poky/meta/recipes-sato/puzzles/puzzles_git.bb
@@ -17,7 +17,7 @@
            "
 
 UPSTREAM_CHECK_COMMITS = "1"
-SRCREV = "79a5378b5adc46ee33ba34d55738f916fb8adfc9"
+SRCREV = "66b9e8c7de0eecb3d85d9a1766fab1082848448b"
 PE = "2"
 PV = "0.0+git${SRCPV}"
 
diff --git a/poky/meta/recipes-support/ca-certificates/ca-certificates_20190110.bb b/poky/meta/recipes-support/ca-certificates/ca-certificates_20200601.bb
similarity index 95%
rename from poky/meta/recipes-support/ca-certificates/ca-certificates_20190110.bb
rename to poky/meta/recipes-support/ca-certificates/ca-certificates_20200601.bb
index ce3cb21..37ba51c 100644
--- a/poky/meta/recipes-support/ca-certificates/ca-certificates_20190110.bb
+++ b/poky/meta/recipes-support/ca-certificates/ca-certificates_20200601.bb
@@ -5,7 +5,7 @@
 HOMEPAGE = "http://packages.debian.org/sid/ca-certificates"
 SECTION = "misc"
 LICENSE = "GPL-2.0+ & MPL-2.0"
-LIC_FILES_CHKSUM = "file://debian/copyright;md5=aeb420429b1659507e0a5a1b123e8308"
+LIC_FILES_CHKSUM = "file://debian/copyright;md5=ae5b36b514e3f12ce1aa8e2ee67f3d7e"
 
 # This is needed to ensure we can run the postinst at image creation time
 DEPENDS = ""
@@ -14,7 +14,7 @@
 # Need rehash from openssl and run-parts from debianutils
 PACKAGE_WRITE_DEPS += "openssl-native debianutils-native"
 
-SRCREV = "c28799b138b044c963d24c4a69659b6e5486e3be"
+SRCREV = "b3a8980b781bc9a370e42714a605cd4191bb6c0b"
 
 SRC_URI = "git://salsa.debian.org/debian/ca-certificates.git;protocol=https \
            file://0002-update-ca-certificates-use-SYSROOT.patch \
diff --git a/poky/meta/recipes-support/debianutils/debianutils_4.9.1.bb b/poky/meta/recipes-support/debianutils/debianutils_4.9.1.bb
index 904c527..768f289 100644
--- a/poky/meta/recipes-support/debianutils/debianutils_4.9.1.bb
+++ b/poky/meta/recipes-support/debianutils/debianutils_4.9.1.bb
@@ -35,7 +35,7 @@
 RDEPENDS_${PN} += "${PN}-run-parts"
 RDEPENDS_${PN}_class-native = ""
 
-ALTERNATIVE_PRIORITY="30"
+ALTERNATIVE_PRIORITY = "30"
 ALTERNATIVE_${PN} = "add-shell installkernel remove-shell savelog tempfile which"
 
 ALTERNATIVE_PRIORITY_${PN}-run-parts = "60"
@@ -44,12 +44,12 @@
 ALTERNATIVE_${PN}-doc = "which.1"
 ALTERNATIVE_LINK_NAME[which.1] = "${mandir}/man1/which.1"
 
-ALTERNATIVE_LINK_NAME[add-shell]="${sbindir}/add-shell"
-ALTERNATIVE_LINK_NAME[installkernel]="${sbindir}/installkernel"
-ALTERNATIVE_LINK_NAME[remove-shell]="${sbindir}/remove-shell"
-ALTERNATIVE_LINK_NAME[run-parts]="${base_bindir}/run-parts"
-ALTERNATIVE_LINK_NAME[savelog]="${bindir}/savelog"
-ALTERNATIVE_LINK_NAME[tempfile]="${base_bindir}/tempfile"
-ALTERNATIVE_LINK_NAME[which]="${bindir}/which"
+ALTERNATIVE_LINK_NAME[add-shell] = "${sbindir}/add-shell"
+ALTERNATIVE_LINK_NAME[installkernel] = "${sbindir}/installkernel"
+ALTERNATIVE_LINK_NAME[remove-shell] = "${sbindir}/remove-shell"
+ALTERNATIVE_LINK_NAME[run-parts] = "${base_bindir}/run-parts"
+ALTERNATIVE_LINK_NAME[savelog] = "${bindir}/savelog"
+ALTERNATIVE_LINK_NAME[tempfile] = "${base_bindir}/tempfile"
+ALTERNATIVE_LINK_NAME[which] = "${bindir}/which"
 
 BBCLASSEXTEND = "native"
diff --git a/poky/meta/recipes-support/diffoscope/diffoscope_144.bb b/poky/meta/recipes-support/diffoscope/diffoscope_146.bb
similarity index 75%
rename from poky/meta/recipes-support/diffoscope/diffoscope_144.bb
rename to poky/meta/recipes-support/diffoscope/diffoscope_146.bb
index 3a877ca..a3402d4 100644
--- a/poky/meta/recipes-support/diffoscope/diffoscope_144.bb
+++ b/poky/meta/recipes-support/diffoscope/diffoscope_146.bb
@@ -7,8 +7,7 @@
 
 inherit pypi setuptools3
 
-SRC_URI[md5sum] = "4ee9d1a36086caa31ccbc6300ad31652"
-SRC_URI[sha256sum] = "9a45464b7b7184fa1ad2af9c52ebac8f00b3dd5dcf9e15dfc00c653c26fcc345"
+SRC_URI[sha256sum] = "a031605c043577c908052763e49b0bd9c1d4d8a169eaf41364900ff1d9566ee2"
 
 RDEPENDS_${PN} += "binutils vim squashfs-tools python3-libarchive-c python3-magic"
 
diff --git a/poky/meta/recipes-support/libcap/files/0004-psx.c-replace-pthread_yield-with-standard-sched_yiel.patch b/poky/meta/recipes-support/libcap/files/0004-psx.c-replace-pthread_yield-with-standard-sched_yiel.patch
deleted file mode 100644
index 848ceb2..0000000
--- a/poky/meta/recipes-support/libcap/files/0004-psx.c-replace-pthread_yield-with-standard-sched_yiel.patch
+++ /dev/null
@@ -1,24 +0,0 @@
-From a2c4cdb05d0e382101b13944c09c4375e8d7de5f Mon Sep 17 00:00:00 2001
-From: Alexander Kanavin <alex.kanavin@gmail.com>
-Date: Tue, 31 Mar 2020 13:39:28 +0200
-Subject: [PATCH] psx.c: replace pthread_yield() with standard sched_yield()
-
-This was causing failures when building with musl C library in
-particular.
-
-Upstream-Status: Pending
-Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
----
-diff --git a/libcap/psx.c b/libcap/psx.c
-index 04d250f..7e4ac10 100644
---- a/libcap/psx.c
-+++ b/libcap/psx.c
-@@ -533,7 +533,7 @@ long int __psx_syscall(long int syscall_nr, ...) {
- 	if (!waiting) {
- 	    break;
- 	}
--	pthread_yield();
-+	sched_yield();
-     }
- 
-     errno = restore_errno;
diff --git a/poky/meta/recipes-support/libcap/libcap_2.33.bb b/poky/meta/recipes-support/libcap/libcap_2.34.bb
similarity index 86%
rename from poky/meta/recipes-support/libcap/libcap_2.33.bb
rename to poky/meta/recipes-support/libcap/libcap_2.34.bb
index bec492c..a3bd969 100644
--- a/poky/meta/recipes-support/libcap/libcap_2.33.bb
+++ b/poky/meta/recipes-support/libcap/libcap_2.34.bb
@@ -11,10 +11,9 @@
            file://0001-ensure-the-XATTR_NAME_CAPS-is-defined-when-it-is-use.patch \
            file://0002-tests-do-not-run-target-executables.patch \
            file://0001-tests-do-not-statically-link-a-test.patch \
-           file://0004-psx.c-replace-pthread_yield-with-standard-sched_yiel.patch \
            "
-SRC_URI[md5sum] = "dcc6220b4a9bf260050b20c07edcddf4"
-SRC_URI[sha256sum] = "08edeaba2757021aeec45c4eeec52566675e0e0f5d4f057284d729e04f2643d6"
+SRC_URI[md5sum] = "66028a8080a0891c54b202bb5e749035"
+SRC_URI[sha256sum] = "aecdd42015955068d3d94b7caa9590fcb2de5df53ce53c61a21b912bfc0b1611"
 
 UPSTREAM_CHECK_URI = "https://www.kernel.org/pub/linux/libs/security/linux-privs/${BPN}2/"
 
@@ -26,7 +25,7 @@
 	# libcap uses := for compilers, fortunately, it gives us a hint
 	# on what should be replaced with ?=
 	sed -e 's,:=,?=,g' -i Make.Rules
-	sed -e 's,^BUILD_CFLAGS ?= $(.*CFLAGS),BUILD_CFLAGS := $(BUILD_CFLAGS),' -i Make.Rules
+	sed -e 's,^BUILD_CFLAGS ?= ,BUILD_CFLAGS := $(BUILD_CFLAGS) ,' -i Make.Rules
 }
 
 PACKAGECONFIG ??= "${@bb.utils.filter('DISTRO_FEATURES', 'pam', d)}"
diff --git a/poky/meta/recipes-support/libexif/libexif/CVE-2016-6328.patch b/poky/meta/recipes-support/libexif/libexif/CVE-2016-6328.patch
deleted file mode 100644
index a6f3074..0000000
--- a/poky/meta/recipes-support/libexif/libexif/CVE-2016-6328.patch
+++ /dev/null
@@ -1,64 +0,0 @@
-CVE: CVE-2016-6328
-Upstream-Status: Backport
-Signed-off-by: Ross Burton <ross.burton@intel.com>
-
-From 41bd04234b104312f54d25822f68738ba8d7133d Mon Sep 17 00:00:00 2001
-From: Marcus Meissner <marcus@jet.franken.de>
-Date: Tue, 25 Jul 2017 23:44:44 +0200
-Subject: [PATCH] fixes some (not all) buffer overreads during decoding pentax
- makernote entries.
-
-This should fix:
-https://sourceforge.net/p/libexif/bugs/125/ CVE-2016-6328
----
- libexif/pentax/mnote-pentax-entry.c | 16 +++++++++++++---
- 1 file changed, 13 insertions(+), 3 deletions(-)
-
-diff --git a/libexif/pentax/mnote-pentax-entry.c b/libexif/pentax/mnote-pentax-entry.c
-index d03d159..ea0429a 100644
---- a/libexif/pentax/mnote-pentax-entry.c
-+++ b/libexif/pentax/mnote-pentax-entry.c
-@@ -425,24 +425,34 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
- 		case EXIF_FORMAT_SHORT:
- 		  {
- 			const unsigned char *data = entry->data;
--		  	size_t k, len = strlen(val);
-+		  	size_t k, len = strlen(val), sizeleft;
-+
-+			sizeleft = entry->size;
- 		  	for(k=0; k<entry->components; k++) {
-+				if (sizeleft < 2)
-+					break;
- 				vs = exif_get_short (data, entry->order);
- 				snprintf (val+len, maxlen-len, "%i ", vs);
- 				len = strlen(val);
- 				data += 2;
-+				sizeleft -= 2;
- 			}
- 		  }
- 		  break;
- 		case EXIF_FORMAT_LONG:
- 		  {
- 			const unsigned char *data = entry->data;
--		  	size_t k, len = strlen(val);
-+		  	size_t k, len = strlen(val), sizeleft;
-+
-+			sizeleft = entry->size;
- 		  	for(k=0; k<entry->components; k++) {
-+				if (sizeleft < 4)
-+					break;
- 				vl = exif_get_long (data, entry->order);
- 				snprintf (val+len, maxlen-len, "%li", (long int) vl);
- 				len = strlen(val);
- 				data += 4;
-+				sizeleft -= 4;
- 			}
- 		  }
- 		  break;
-@@ -455,5 +465,5 @@ mnote_pentax_entry_get_value (MnotePentaxEntry *entry,
- 		break;
- 	}
- 
--	return (val);
-+	return val;
- }
diff --git a/poky/meta/recipes-support/libexif/libexif/CVE-2017-7544.patch b/poky/meta/recipes-support/libexif/libexif/CVE-2017-7544.patch
deleted file mode 100644
index e49481f..0000000
--- a/poky/meta/recipes-support/libexif/libexif/CVE-2017-7544.patch
+++ /dev/null
@@ -1,40 +0,0 @@
-From 8a92f964a66d476ca8907234359e92a70fc1325b Mon Sep 17 00:00:00 2001
-From: Changqing Li <changqing.li@windriver.com>
-Date: Tue, 28 Aug 2018 15:12:10 +0800
-Subject: [PATCH] On saving makernotes, make sure the makernote container tags
- has a type with 1 byte components.
-
-Fixes (at least):
-	https://sourceforge.net/p/libexif/bugs/130
-	https://sourceforge.net/p/libexif/bugs/129
-
-Upstream-Status: Backport[https://github.com/libexif/libexif/commit/
-c39acd1692023b26290778a02a9232c873f9d71a#diff-830e348923810f00726700b083ec00cd]
-
-CVE: CVE-2017-7544
-
-Signed-off-by: Changqing Li <changqing.li@windriver.com>
----
- libexif/exif-data.c | 6 ++++++
- 1 file changed, 6 insertions(+)
-
-diff --git a/libexif/exif-data.c b/libexif/exif-data.c
-index 67df4db..6bf89eb 100644
---- a/libexif/exif-data.c
-+++ b/libexif/exif-data.c
-@@ -255,6 +255,12 @@ exif_data_save_data_entry (ExifData *data, ExifEntry *e,
- 			exif_mnote_data_set_offset (data->priv->md, *ds - 6);
- 			exif_mnote_data_save (data->priv->md, &e->data, &e->size);
- 			e->components = e->size;
-+                        if (exif_format_get_size (e->format) != 1) {
-+				/* e->format is taken from input code,
-+				 * but we need to make sure it is a 1 byte
-+				 * entity due to the multiplication below. */
-+				e->format = EXIF_FORMAT_UNDEFINED;
-+			}
- 		}
- 	}
- 
--- 
-2.7.4
-
diff --git a/poky/meta/recipes-support/libexif/libexif/CVE-2018-20030.patch b/poky/meta/recipes-support/libexif/libexif/CVE-2018-20030.patch
deleted file mode 100644
index 76233e6..0000000
--- a/poky/meta/recipes-support/libexif/libexif/CVE-2018-20030.patch
+++ /dev/null
@@ -1,115 +0,0 @@
-CVE: CVE-2018-20030
-Upstream-Status: Backport
-Signed-off-by: Ross Burton <ross.burton@intel.com>
-
-From 6aa11df549114ebda520dde4cdaea2f9357b2c89 Mon Sep 17 00:00:00 2001
-From: Dan Fandrich <dan@coneharvesters.com>
-Date: Fri, 12 Oct 2018 16:01:45 +0200
-Subject: [PATCH] Improve deep recursion detection in
- exif_data_load_data_content.
-
-The existing detection was still vulnerable to pathological cases
-causing DoS by wasting CPU. The new algorithm takes the number of tags
-into account to make it harder to abuse by cases using shallow recursion
-but with a very large number of tags.  This improves on commit 5d28011c
-which wasn't sufficient to counter this kind of case.
-
-The limitation in the previous fix was discovered by Laurent Delosieres,
-Secunia Research at Flexera (Secunia Advisory SA84652) and is assigned
-the identifier CVE-2018-20030.
-
-diff --git a/libexif/exif-data.c b/libexif/exif-data.c
-index 67df4db..8d9897e 100644
---- a/libexif/exif-data.c
-+++ b/libexif/exif-data.c
-@@ -35,6 +35,7 @@
- #include <libexif/olympus/exif-mnote-data-olympus.h>
- #include <libexif/pentax/exif-mnote-data-pentax.h>
- 
-+#include <math.h>
- #include <stdlib.h>
- #include <stdio.h>
- #include <string.h>
-@@ -344,6 +345,20 @@ if (data->ifd[(i)]->count) {				\
- 	break;						\
- }
- 
-+/*! Calculate the recursion cost added by one level of IFD loading.
-+ *
-+ * The work performed is related to the cost in the exponential relation
-+ *   work=1.1**cost
-+ */
-+static unsigned int
-+level_cost(unsigned int n)
-+{
-+    static const double log_1_1 = 0.09531017980432493;
-+
-+	/* Adding 0.1 protects against the case where n==1 */
-+	return ceil(log(n + 0.1)/log_1_1);
-+}
-+
- /*! Load data for an IFD.
-  *
-  * \param[in,out] data #ExifData
-@@ -351,13 +366,13 @@ if (data->ifd[(i)]->count) {				\
-  * \param[in] d pointer to buffer containing raw IFD data
-  * \param[in] ds size of raw data in buffer at \c d
-  * \param[in] offset offset into buffer at \c d at which IFD starts
-- * \param[in] recursion_depth number of times this function has been
-- * recursively called without returning
-+ * \param[in] recursion_cost factor indicating how expensive this recursive
-+ * call could be
-  */
- static void
- exif_data_load_data_content (ExifData *data, ExifIfd ifd,
- 			     const unsigned char *d,
--			     unsigned int ds, unsigned int offset, unsigned int recursion_depth)
-+			     unsigned int ds, unsigned int offset, unsigned int recursion_cost)
- {
- 	ExifLong o, thumbnail_offset = 0, thumbnail_length = 0;
- 	ExifShort n;
-@@ -372,9 +387,20 @@ exif_data_load_data_content (ExifData *data, ExifIfd ifd,
- 	if ((((int)ifd) < 0) || ( ((int)ifd) >= EXIF_IFD_COUNT))
- 	  return;
- 
--	if (recursion_depth > 30) {
-+	if (recursion_cost > 170) {
-+		/*
-+		 * recursion_cost is a logarithmic-scale indicator of how expensive this
-+		 * recursive call might end up being. It is an indicator of the depth of
-+		 * recursion as well as the potential for worst-case future recursive
-+		 * calls. Since it's difficult to tell ahead of time how often recursion
-+		 * will occur, this assumes the worst by assuming every tag could end up
-+		 * causing recursion.
-+		 * The value of 170 was chosen to limit typical EXIF structures to a
-+		 * recursive depth of about 6, but pathological ones (those with very
-+		 * many tags) to only 2.
-+		 */
- 		exif_log (data->priv->log, EXIF_LOG_CODE_CORRUPT_DATA, "ExifData",
--			  "Deep recursion detected!");
-+			  "Deep/expensive recursion detected!");
- 		return;
- 	}
- 
-@@ -416,15 +442,18 @@ exif_data_load_data_content (ExifData *data, ExifIfd ifd,
- 			switch (tag) {
- 			case EXIF_TAG_EXIF_IFD_POINTER:
- 				CHECK_REC (EXIF_IFD_EXIF);
--				exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o, recursion_depth + 1);
-+				exif_data_load_data_content (data, EXIF_IFD_EXIF, d, ds, o,
-+					recursion_cost + level_cost(n));
- 				break;
- 			case EXIF_TAG_GPS_INFO_IFD_POINTER:
- 				CHECK_REC (EXIF_IFD_GPS);
--				exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o, recursion_depth + 1);
-+				exif_data_load_data_content (data, EXIF_IFD_GPS, d, ds, o,
-+					recursion_cost + level_cost(n));
- 				break;
- 			case EXIF_TAG_INTEROPERABILITY_IFD_POINTER:
- 				CHECK_REC (EXIF_IFD_INTEROPERABILITY);
--				exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o, recursion_depth + 1);
-+				exif_data_load_data_content (data, EXIF_IFD_INTEROPERABILITY, d, ds, o,
-+					recursion_cost + level_cost(n));
- 				break;
- 			case EXIF_TAG_JPEG_INTERCHANGE_FORMAT:
- 				thumbnail_offset = o;
diff --git a/poky/meta/recipes-support/libexif/libexif_0.6.21.bb b/poky/meta/recipes-support/libexif/libexif_0.6.21.bb
deleted file mode 100644
index d847bea..0000000
--- a/poky/meta/recipes-support/libexif/libexif_0.6.21.bb
+++ /dev/null
@@ -1,17 +0,0 @@
-SUMMARY = "Library for reading extended image information (EXIF) from JPEG files"
-HOMEPAGE = "http://sourceforge.net/projects/libexif"
-SECTION = "libs"
-LICENSE = "LGPLv2.1"
-LIC_FILES_CHKSUM = "file://COPYING;md5=243b725d71bb5df4a1e5920b344b86ad"
-
-SRC_URI = "${SOURCEFORGE_MIRROR}/libexif/libexif-${PV}.tar.bz2 \
-           file://CVE-2017-7544.patch \
-           file://CVE-2016-6328.patch \
-           file://CVE-2018-20030.patch"
-
-SRC_URI[md5sum] = "27339b89850f28c8f1c237f233e05b27"
-SRC_URI[sha256sum] = "16cdaeb62eb3e6dfab2435f7d7bccd2f37438d21c5218ec4e58efa9157d4d41a"
-
-inherit autotools gettext
-
-EXTRA_OECONF += "--disable-docs"
diff --git a/poky/meta/recipes-support/libexif/libexif_0.6.22.bb b/poky/meta/recipes-support/libexif/libexif_0.6.22.bb
new file mode 100644
index 0000000..a520d5c
--- /dev/null
+++ b/poky/meta/recipes-support/libexif/libexif_0.6.22.bb
@@ -0,0 +1,19 @@
+SUMMARY = "Library for reading extended image information (EXIF) from JPEG files"
+HOMEPAGE = "https://libexif.github.io/"
+SECTION = "libs"
+LICENSE = "LGPLv2.1"
+LIC_FILES_CHKSUM = "file://COPYING;md5=243b725d71bb5df4a1e5920b344b86ad"
+
+def version_underscore(v):
+    return "_".join(v.split("."))
+
+SRC_URI = "https://github.com/libexif/libexif/releases/download/libexif-${@version_underscore("${PV}")}-release/libexif-${PV}.tar.xz \
+           "
+
+SRC_URI[sha256sum] = "5048f1c8fc509cc636c2f97f4b40c293338b6041a5652082d5ee2cf54b530c56"
+
+UPSTREAM_CHECK_URI = "https://github.com/libexif/libexif/releases/"
+
+inherit autotools gettext
+
+EXTRA_OECONF += "--disable-docs"
diff --git a/poky/meta/recipes-support/libical/libical_3.0.7.bb b/poky/meta/recipes-support/libical/libical_3.0.8.bb
similarity index 93%
rename from poky/meta/recipes-support/libical/libical_3.0.7.bb
rename to poky/meta/recipes-support/libical/libical_3.0.8.bb
index a50473e..efb9433 100644
--- a/poky/meta/recipes-support/libical/libical_3.0.7.bb
+++ b/poky/meta/recipes-support/libical/libical_3.0.8.bb
@@ -12,8 +12,8 @@
     https://github.com/${BPN}/${BPN}/releases/download/v${PV}/${BP}.tar.gz \
     file://0001-Use-our-hand-build-native-src-generator.patch \
 "
-SRC_URI[md5sum] = "8a5d07a7fba9e73a85e67f76258bf042"
-SRC_URI[sha256sum] = "0abe66df1ea826e57db7f281c704ede834c84139012e6c686ea7adafd4e763fc"
+SRC_URI[md5sum] = "41bd1f1fcdcb4779cea478bb55cf07bf"
+SRC_URI[sha256sum] = "09fecacaf75ba5a242159e3a9758a5446b5ce4d0ab684f98a7040864e1d1286f"
 UPSTREAM_CHECK_URI = "https://github.com/libical/libical/releases"
 
 inherit cmake pkgconfig
diff --git a/poky/meta/recipes-support/libpcre/libpcre2/pcre-cross.patch b/poky/meta/recipes-support/libpcre/libpcre2/pcre-cross.patch
deleted file mode 100644
index 871cdfc..0000000
--- a/poky/meta/recipes-support/libpcre/libpcre2/pcre-cross.patch
+++ /dev/null
@@ -1,65 +0,0 @@
-Fix for cross compiling
-
-Fixed:
-| ./dftables src/pcre2_chartables.c
-| make: ./dftables: Command not found
-| make: *** [src/pcre2_chartables.c] Error 127
-
-Upstream-Status: Pending
-
-Signed-off-by: Robert Yang <liezhi.yang@windriver.com>
-
-Index: pcre2-10.30/Makefile.am
-===================================================================
---- pcre2-10.30.orig/Makefile.am
-+++ pcre2-10.30/Makefile.am
-@@ -325,9 +325,21 @@ bin_SCRIPTS = pcre2-config
- ## to copy a distributed set of tables that are defined for ASCII code. In this
- ## case, dftables is not needed.
- 
-+CC_FOR_BUILD = @CC_FOR_BUILD@
-+CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
-+CCLD_FOR_BUILD = @CCLD_FOR_BUILD@
-+LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@
-+
- if WITH_REBUILD_CHARTABLES
- noinst_PROGRAMS += dftables
- dftables_SOURCES = src/dftables.c
-+
-+dftables_LINK = $(CCLD_FOR_BUILD) -o $@
-+dftables_LDFLAGS = $(LDFLAGS_FOR_BUILD)
-+
-+src/dftables.o: $(srcdir)/src/dftables.c
-+	$(CC_FOR_BUILD) -c $(CFLAGS_FOR_BUILD) -o $@ $(srcdir)/src/dftables.c
-+
- src/pcre2_chartables.c: dftables$(EXEEXT)
- 	rm -f $@
- 	./dftables$(EXEEXT) $@
-Index: pcre2-10.30/configure.ac
-===================================================================
---- pcre2-10.30.orig/configure.ac
-+++ pcre2-10.30/configure.ac
-@@ -60,6 +60,23 @@ fi
- # This is a new thing required to stop a warning from automake 1.12
- m4_ifdef([AM_PROG_AR], [AM_PROG_AR])
- 
-+if test x"$cross_compiling" = xyes; then
-+    CC_FOR_BUILD="${CC_FOR_BUILD-gcc}"
-+    CCLD_FOR_BUILD="${CCLD_FOR_BUILD-gcc}"
-+    CFLAGS_FOR_BUILD="${CFLAGS_FOR_BUILD}"
-+    LDFLAGS_FOR_BUILD="${LDFLAGS_FOR_BUILD}"
-+else
-+    CC_FOR_BUILD="${CC_FOR_BUILD-\$(CC)}"
-+    CCLD_FOR_BUILD="${CCLD_FOR_BUILD-\$(CCLD)}"
-+    CFLAGS_FOR_BUILD="${CFLAGS_FOR_BUILD-\$(CFLAGS)}"
-+    LDFLAGS_FOR_BUILD="${LDFLAGS_FOR_BUILD-\$(LDFLAGS)}"
-+fi
-+AC_ARG_VAR(CC_FOR_BUILD, [build system C compiler])
-+AC_ARG_VAR(CCLD_FOR_BUILD, [build system C linker frontend])
-+AC_ARG_VAR(CFLAGS_FOR_BUILD, [build system C compiler arguments])
-+AC_ARG_VAR(LDFLAGS_FOR_BUILD, [build system C linker frontend arguments])
-+
-+
- # Check for a 64-bit integer type
- AC_TYPE_INT64_T
- 
diff --git a/poky/meta/recipes-support/libpcre/libpcre2_10.34.bb b/poky/meta/recipes-support/libpcre/libpcre2_10.35.bb
similarity index 74%
rename from poky/meta/recipes-support/libpcre/libpcre2_10.34.bb
rename to poky/meta/recipes-support/libpcre/libpcre2_10.35.bb
index fa8655e..35c019c 100644
--- a/poky/meta/recipes-support/libpcre/libpcre2_10.34.bb
+++ b/poky/meta/recipes-support/libpcre/libpcre2_10.35.bb
@@ -8,14 +8,11 @@
 HOMEPAGE = "http://www.pcre.org"
 SECTION = "devel"
 LICENSE = "BSD-3-Clause"
-LIC_FILES_CHKSUM = "file://LICENCE;md5=b1588d3bb4cb0e1f5a597d908f8c5b37"
+LIC_FILES_CHKSUM = "file://LICENCE;md5=a06590e9bd4c229532364727aaeaf084"
 
-SRC_URI = "https://ftp.pcre.org/pub/pcre/pcre2-${PV}.tar.bz2 \
-           file://pcre-cross.patch \
-"
+SRC_URI = "https://ftp.pcre.org/pub/pcre/pcre2-${PV}.tar.bz2"
 
-SRC_URI[md5sum] = "d280b62ded13f9ccf2fac16ee5286366"
-SRC_URI[sha256sum] = "74c473ffaba9e13db6951fd146e0143fe9887852ce73406a03277af1d9b798ca"
+SRC_URI[sha256sum] = "9ccba8e02b0ce78046cdfb52e5c177f0f445e421059e43becca4359c669d4613"
 
 CVE_PRODUCT = "pcre2"
 
@@ -30,20 +27,14 @@
 
 EXTRA_OECONF = "\
     --enable-newline-is-lf \
-    --enable-rebuild-chartables \
     --with-link-size=2 \
     --with-match-limit=10000000 \
     --enable-pcre2-16 \
     --enable-pcre2-32 \
 "
-# Set LINK_SIZE in BUILD_CFLAGS given that the autotools bbclass use it to
-# set CFLAGS_FOR_BUILD, required for the libpcre build.
-BUILD_CFLAGS =+ "-DLINK_SIZE=2 -I${B}/src"
 CFLAGS += "-D_REENTRANT"
 CXXFLAGS_append_powerpc = " -lstdc++"
 
-export CCLD_FOR_BUILD ="${BUILD_CCLD}"
-
 PACKAGES =+ "libpcre2-16 libpcre2-32 pcre2grep pcre2grep-doc pcre2test pcre2test-doc"
 
 SUMMARY_pcre2grep = "grep utility that uses perl 5 compatible regexes"
diff --git a/poky/meta/recipes-support/libunwind/libunwind/musl-header-conflict.patch b/poky/meta/recipes-support/libunwind/libunwind/musl-header-conflict.patch
index 79f63fd..63b78a8 100644
--- a/poky/meta/recipes-support/libunwind/libunwind/musl-header-conflict.patch
+++ b/poky/meta/recipes-support/libunwind/libunwind/musl-header-conflict.patch
@@ -1,4 +1,7 @@
-If you:
+From 49b21f0fe5fb93b30b94cc449429fd33de0652a7 Mon Sep 17 00:00:00 2001
+From: Richard Purdie <richard.purdie@linuxfoundation.org>
+Date: Thu, 18 Aug 2016 14:46:32 +0100
+Subject: [PATCH] If you:
 
 TCLIBC=musl bitbake unwind
 TCLIBC=musl bitbake gcc-runtime -c cleansstate
@@ -6,12 +9,12 @@
 
 you will see libstdc++ fail to build due to finding libunwind's header file.
 
-Khem: "When we build any of gcc components they expect to use internal version 
-and that works with glibc based gcc since the search headers first look into gcc 
-headers, however with musl the gcc headers are searched after the standard 
+Khem: "When we build any of gcc components they expect to use internal version
+and that works with glibc based gcc since the search headers first look into gcc
+headers, however with musl the gcc headers are searched after the standard
 headers ( which is by design the right thing )."
 
-This patch hacks around the issue by looking for a define used during gcc-runtime's 
+This patch hacks around the issue by looking for a define used during gcc-runtime's
 build and skipping to the internal header in that case.
 
 [YOCTO #10129]
@@ -20,11 +23,15 @@
 
 Upstream-Status: Inappropriate [really need to fix gcc]
 
-Index: git/include/unwind.h
-===================================================================
---- git.orig/include/unwind.h
-+++ git/include/unwind.h
-@@ -23,6 +23,10 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER L
+---
+ include/unwind.h | 4 ++++
+ 1 file changed, 4 insertions(+)
+
+diff --git a/include/unwind.h b/include/unwind.h
+index 7cf128d..31c2871 100644
+--- a/include/unwind.h
++++ b/include/unwind.h
+@@ -23,6 +23,10 @@ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  
diff --git a/poky/meta/recipes-support/libunwind/libunwind_1.3.1.bb b/poky/meta/recipes-support/libunwind/libunwind_1.4.0.bb
similarity index 86%
rename from poky/meta/recipes-support/libunwind/libunwind_1.3.1.bb
rename to poky/meta/recipes-support/libunwind/libunwind_1.4.0.bb
index 037e04c..f50205f 100644
--- a/poky/meta/recipes-support/libunwind/libunwind_1.3.1.bb
+++ b/poky/meta/recipes-support/libunwind/libunwind_1.4.0.bb
@@ -10,8 +10,8 @@
            "
 SRC_URI_append_libc-musl = " file://musl-header-conflict.patch"
 
-SRC_URI[md5sum] = "a04f69d66d8e16f8bf3ab72a69112cd6"
-SRC_URI[sha256sum] = "43997a3939b6ccdf2f669b50fdb8a4d3205374728c2923ddc2354c65260214f8"
+SRC_URI[md5sum] = "5114504c74ac3992ac06aa551cd55678"
+SRC_URI[sha256sum] = "df59c931bd4d7ebfd83ee481c943edf015138089b8e50abed8d9c57ba9338435"
 
 EXTRA_OECONF_append_libc-musl = " --disable-documentation --disable-tests --enable-static"
 
diff --git a/poky/meta/recipes-support/liburcu/liburcu_0.12.0.bb b/poky/meta/recipes-support/liburcu/liburcu_0.12.1.bb
similarity index 83%
rename from poky/meta/recipes-support/liburcu/liburcu_0.12.0.bb
rename to poky/meta/recipes-support/liburcu/liburcu_0.12.1.bb
index 0c20abe..3a5ecbc 100644
--- a/poky/meta/recipes-support/liburcu/liburcu_0.12.0.bb
+++ b/poky/meta/recipes-support/liburcu/liburcu_0.12.1.bb
@@ -9,8 +9,8 @@
 
 SRC_URI = "http://lttng.org/files/urcu/userspace-rcu-${PV}.tar.bz2"
 
-SRC_URI[md5sum] = "d923a42ce38e33e883313003c8afd559"
-SRC_URI[sha256sum] = "409b1be506989e1d26543194df1a79212be990fe5d4fd84f34f019efed989f97"
+SRC_URI[md5sum] = "5e419d7b30d0d98bffe0014c704ae936"
+SRC_URI[sha256sum] = "bbfaead0345642b97e0de90f889dfbab4b2643a6a5e5c6bb59cd0d26fc0bcd0e"
 
 S = "${WORKDIR}/userspace-rcu-${PV}"
 inherit autotools multilib_header
diff --git a/poky/meta/recipes-support/libyaml/libyaml_0.2.2.bb b/poky/meta/recipes-support/libyaml/libyaml_0.2.5.bb
similarity index 66%
rename from poky/meta/recipes-support/libyaml/libyaml_0.2.2.bb
rename to poky/meta/recipes-support/libyaml/libyaml_0.2.5.bb
index 5105ce6..e39a7b9 100644
--- a/poky/meta/recipes-support/libyaml/libyaml_0.2.2.bb
+++ b/poky/meta/recipes-support/libyaml/libyaml_0.2.5.bb
@@ -5,11 +5,11 @@
 SECTION = "libs/devel"
 
 LICENSE = "MIT"
-LIC_FILES_CHKSUM = "file://LICENSE;md5=a76b4c69bfcf82313bbdc0393b04438a"
+LIC_FILES_CHKSUM = "file://License;md5=7bbd28caa69f81f5cd5f48647236663d"
 
 SRC_URI = "https://pyyaml.org/download/libyaml/yaml-${PV}.tar.gz"
-SRC_URI[md5sum] = "54bf11ccb8bc488b5b3bec931f5b70dc"
-SRC_URI[sha256sum] = "4a9100ab61047fd9bd395bcef3ce5403365cafd55c1e0d0299cde14958e47be9"
+SRC_URI[md5sum] = "bb15429d8fb787e7d3f1c83ae129a999"
+SRC_URI[sha256sum] = "c642ae9b75fee120b2d96c712538bd2cf283228d2337df2cf2988e3c02678ef4"
 
 S = "${WORKDIR}/yaml-${PV}"
 
diff --git a/poky/meta/recipes-support/lz4/lz4_1.9.2.bb b/poky/meta/recipes-support/lz4/lz4_1.9.2.bb
index ed4452c..6510156 100644
--- a/poky/meta/recipes-support/lz4/lz4_1.9.2.bb
+++ b/poky/meta/recipes-support/lz4/lz4_1.9.2.bb
@@ -21,7 +21,7 @@
 # Fixed in r118, which is larger than the current version.
 CVE_CHECK_WHITELIST += "CVE-2014-4715"
 
-EXTRA_OEMAKE = "PREFIX=${prefix} CC='${CC}' DESTDIR=${D} LIBDIR=${libdir} INCLUDEDIR=${includedir}"
+EXTRA_OEMAKE = "PREFIX=${prefix} CC='${CC}' DESTDIR=${D} LIBDIR=${libdir} INCLUDEDIR=${includedir} BUILD_STATIC=no"
 
 do_install() {
 	oe_runmake install
diff --git a/poky/meta/recipes-support/ptest-runner/ptest-runner_2.4.0.bb b/poky/meta/recipes-support/ptest-runner/ptest-runner_2.4.0.bb
index 09fabde..0a3186d 100644
--- a/poky/meta/recipes-support/ptest-runner/ptest-runner_2.4.0.bb
+++ b/poky/meta/recipes-support/ptest-runner/ptest-runner_2.4.0.bb
@@ -12,6 +12,7 @@
 
 SRC_URI = "git://git.yoctoproject.org/ptest-runner2 \
 "
+UPSTREAM_VERSION_UNKNOWN = "1"
 
 S = "${WORKDIR}/git"
 
diff --git a/poky/meta/recipes-support/re2c/re2c/CVE-2020-11958.patch b/poky/meta/recipes-support/re2c/re2c/CVE-2020-11958.patch
new file mode 100644
index 0000000..43462e6
--- /dev/null
+++ b/poky/meta/recipes-support/re2c/re2c/CVE-2020-11958.patch
@@ -0,0 +1,41 @@
+From c4603ba5ce229db83a2a4fb93e6d4b4e3ec3776a Mon Sep 17 00:00:00 2001
+From: Ulya Trofimovich <skvadrik@gmail.com>
+Date: Fri, 17 Apr 2020 22:47:14 +0100
+Subject: [PATCH] Fix crash in lexer refill (reported by Agostino Sarubbo).
+
+The crash happened in a rare case of a very long lexeme that doen't fit
+into the buffer, forcing buffer reallocation.
+
+The crash was caused by an incorrect calculation of the shift offset
+(it was smaller than necessary). As a consequence, the data from buffer
+start and up to the beginning of the current lexeme was not discarded
+(as it should have been), resulting in less free space for new data than
+expected.
+
+Upstream-Status: Backport [https://github.com/skvadrik/re2c/commit/c4603ba5ce229db83a2a4fb93e6d4b4e3ec3776a]
+CVE: CVE-2020-11958
+Signed-off-by: Lee Chee Yang <chee.yang.lee@intel.com>
+---
+ src/parse/scanner.cc | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/src/parse/scanner.cc b/src/parse/scanner.cc
+index 1d6e9efa..bd651314 100644
+--- a/src/parse/scanner.cc
++++ b/src/parse/scanner.cc
+@@ -155,13 +155,14 @@ bool Scanner::fill(size_t need)
+         if (!buf) fatal("out of memory");
+ 
+         memmove(buf, tok, copy);
+-        shift_ptrs_and_fpos(buf - bot);
++        shift_ptrs_and_fpos(buf - tok);
+         delete [] bot;
+         bot = buf;
+ 
+         free = BSIZE - copy;
+     }
+ 
++    DASSERT(lim + free <= bot + BSIZE);
+     if (!read(free)) {
+         eof = lim;
+         memset(lim, 0, YYMAXFILL);
diff --git a/poky/meta/recipes-support/re2c/re2c_1.3.bb b/poky/meta/recipes-support/re2c/re2c_1.3.bb
index 0e1d938..e9053ac 100644
--- a/poky/meta/recipes-support/re2c/re2c_1.3.bb
+++ b/poky/meta/recipes-support/re2c/re2c_1.3.bb
@@ -5,7 +5,9 @@
 LICENSE = "PD"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=64eca4d8a3b67f9dc7656094731a2c8d"
 
-SRC_URI = "https://github.com/skvadrik/re2c/releases/download/${PV}/${BPN}-${PV}.tar.xz"
+SRC_URI = "https://github.com/skvadrik/re2c/releases/download/${PV}/${BPN}-${PV}.tar.xz \
+           file://CVE-2020-11958.patch \
+"
 SRC_URI[sha256sum] = "f37f25ff760e90088e7d03d1232002c2c2672646d5844fdf8e0d51a5cd75a503"
 UPSTREAM_CHECK_URI = "https://github.com/skvadrik/re2c/releases"
 
diff --git a/poky/meta/recipes-support/rng-tools/rng-tools/a4b6d9ce64f132e463b9091d0536913ddaf11516.patch b/poky/meta/recipes-support/rng-tools/rng-tools/a4b6d9ce64f132e463b9091d0536913ddaf11516.patch
new file mode 100644
index 0000000..9630161
--- /dev/null
+++ b/poky/meta/recipes-support/rng-tools/rng-tools/a4b6d9ce64f132e463b9091d0536913ddaf11516.patch
@@ -0,0 +1,42 @@
+From a4b6d9ce64f132e463b9091d0536913ddaf11516 Mon Sep 17 00:00:00 2001
+From: Neil Horman <nhorman@tuxdriver.com>
+Date: Thu, 30 Apr 2020 16:57:35 -0400
+Subject: [PATCH] Remove name conflict with libc encrypt
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Forgot to fixup the funciton name conflict with libcs encrypt() function
+on power systems
+
+Upstream-Status: Backport [https://github.com/nhorman/rng-tools/commit/a4b6d9ce64f132e463b9091d0536913ddaf11516]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
+Reported-by: Natanael Copa <ncopa@alpinelinux.org>
+Reported-by: "Milan P. Stanić" <mps@arvanta.net>
+---
+ rngd_darn.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/rngd_darn.c b/rngd_darn.c
+index 35df7a1..9345895 100644
+--- a/rngd_darn.c
++++ b/rngd_darn.c
+@@ -109,7 +109,7 @@ static int init_openssl(struct rng *ent_src)
+ 	return 0;
+ }
+ 
+-int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
++static int osslencrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
+             unsigned char *iv, unsigned char *ciphertext)
+ {
+         int len;
+@@ -150,7 +150,7 @@ static inline int openssl_mangle(unsigned char *tmp, struct rng *ent_src)
+         unsigned char ciphertext[CHUNK_SIZE * RDRAND_ROUNDS];
+ 
+         /* Encrypt the plaintext */
+-        ciphertext_len = encrypt (tmp, strlen(tmp), key, iv_buf,
++        ciphertext_len = osslencrypt (tmp, strlen(tmp), key, iv_buf,
+                               ciphertext);
+         printf("Calling mangle with len %d\n", ciphertext_len);
+         if (!ciphertext_len)
diff --git a/poky/meta/recipes-support/rng-tools/rng-tools/dab16a5fd4efde8ef569b358e19b1fcbc7d0d938.patch b/poky/meta/recipes-support/rng-tools/rng-tools/dab16a5fd4efde8ef569b358e19b1fcbc7d0d938.patch
new file mode 100644
index 0000000..93103ef
--- /dev/null
+++ b/poky/meta/recipes-support/rng-tools/rng-tools/dab16a5fd4efde8ef569b358e19b1fcbc7d0d938.patch
@@ -0,0 +1,51 @@
+From dab16a5fd4efde8ef569b358e19b1fcbc7d0d938 Mon Sep 17 00:00:00 2001
+From: Fabrice Fontaine <fontaine.fabrice@gmail.com>
+Date: Mon, 30 Mar 2020 00:10:46 +0200
+Subject: [PATCH] rngd_jitter: disambiguate call to encrypt
+
+Commit 0f184ea7e792427fb20afe81d471b565aee96f0b disambiguate the call to
+encrypt in rngd_rdrand.c but did not update rngd_jitter.c.
+
+This raise the following build failure:
+
+rngd_jitter.c:75:12: error: conflicting types for 'encrypt'
+ static int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
+            ^~~~~~~
+In file included from rngd_jitter.c:27:
+/home/dawncrow/buildroot-test/scripts/instance-0/output-1/host/powerpc-buildroot-linux-uclibc/sysroot/usr/include/unistd.h:1132:13: note: previous declaration of 'encrypt' was here
+ extern void encrypt (char *__block, int __edflag) __THROW __nonnull ((1));
+             ^~~~~~~
+Makefile:770: recipe for target 'rngd-rngd_jitter.o' failed
+
+Fixes:
+ - http://autobuild.buildroot.org/results/0ca6bf16e3acbc94065b88c4442d6595424b77cb
+
+Upstream-Status: Backport [https://github.com/nhorman/rng-tools/commit/dab16a5fd4efde8ef569b358e19b1fcbc7d0d938]
+Signed-off-by: Alexander Kanavin <alex.kanavin@gmail.com>
+Signed-off-by: Fabrice Fontaine <fontaine.fabrice@gmail.com>
+---
+ rngd_jitter.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/rngd_jitter.c b/rngd_jitter.c
+index c1b1aca..49a3825 100644
+--- a/rngd_jitter.c
++++ b/rngd_jitter.c
+@@ -72,7 +72,7 @@ unsigned char *aes_buf;
+ char key[AES_BLOCK];
+ static unsigned char iv_buf[CHUNK_SIZE] __attribute__((aligned(128)));
+ 
+-static int encrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
++static int osslencrypt(unsigned char *plaintext, int plaintext_len, unsigned char *key,
+             unsigned char *iv, unsigned char *ciphertext)
+ {
+         EVP_CIPHER_CTX *ctx;
+@@ -122,7 +122,7 @@ static inline int openssl_mangle(unsigned char *tmp, struct rng *ent_src)
+         unsigned char ciphertext[CHUNK_SIZE * RDRAND_ROUNDS];
+ 
+         /* Encrypt the plaintext */
+-        ciphertext_len = encrypt (tmp, strlen(tmp), key, iv_buf,
++        ciphertext_len = osslencrypt (tmp, strlen(tmp), key, iv_buf,
+                               ciphertext);
+         if (!ciphertext_len)
+                 return -1;
diff --git a/poky/meta/recipes-support/rng-tools/rng-tools_6.9.bb b/poky/meta/recipes-support/rng-tools/rng-tools_6.10.bb
similarity index 87%
rename from poky/meta/recipes-support/rng-tools/rng-tools_6.9.bb
rename to poky/meta/recipes-support/rng-tools/rng-tools_6.10.bb
index 8c98a9a..3f9720e 100644
--- a/poky/meta/recipes-support/rng-tools/rng-tools_6.9.bb
+++ b/poky/meta/recipes-support/rng-tools/rng-tools_6.10.bb
@@ -6,25 +6,28 @@
 BUGTRACKER = "https://github.com/nhorman/rng-tools/issues"
 LICENSE = "GPLv2"
 LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"
-DEPENDS = "sysfsutils"
+DEPENDS = "sysfsutils openssl"
 
 SRC_URI = "\
     git://github.com/nhorman/rng-tools.git \
+    file://a4b6d9ce64f132e463b9091d0536913ddaf11516.patch \
+    file://dab16a5fd4efde8ef569b358e19b1fcbc7d0d938.patch \
     file://init \
     file://default \
     file://rngd.service \
 "
-SRCREV = "4a865797a69dd38c64a86aa32884ecc9ba7b4d08"
+SRCREV = "0be82200a66d9321451e0a0785bfae350b9cffdc"
 
 S = "${WORKDIR}/git"
 
 inherit autotools update-rc.d systemd pkgconfig
 
-PACKAGECONFIG ??= "libgcrypt libjitterentropy"
+EXTRA_OECONF = "--without-rtlsdr"
+
+PACKAGECONFIG ??= "libjitterentropy"
 PACKAGECONFIG_libc-musl = "libargp libjitterentropy"
 
 PACKAGECONFIG[libargp] = "--with-libargp,--without-libargp,argp-standalone,"
-PACKAGECONFIG[libgcrypt] = "--with-libgcrypt,--without-libgcrypt,libgcrypt,"
 PACKAGECONFIG[libjitterentropy] = "--enable-jitterentropy,--disable-jitterentropy,libjitterentropy"
 PACKAGECONFIG[libp11] = "--with-pkcs11,--without-pkcs11,libp11 openssl"
 PACKAGECONFIG[nistbeacon] = "--with-nistbeacon,--without-nistbeacon,curl libxml2 openssl"
diff --git a/poky/meta/recipes-support/shared-mime-info/shared-mime-info_git.bb b/poky/meta/recipes-support/shared-mime-info/shared-mime-info_git.bb
index 7a060b0..f0d5bc6 100644
--- a/poky/meta/recipes-support/shared-mime-info/shared-mime-info_git.bb
+++ b/poky/meta/recipes-support/shared-mime-info/shared-mime-info_git.bb
@@ -12,9 +12,6 @@
 PV = "1.15"
 S = "${WORKDIR}/git"
 
-UPSTREAM_CHECK_GITTAGREGEX = "Release-(?P<pver>(\d+(\-\d+)+))"
-UPSTREAM_VERSION_UNKNOWN = "1"
-
 inherit autotools pkgconfig gettext python3native mime
 
 EXTRA_OECONF = "--disable-update-mimedb"
diff --git a/poky/meta/recipes-support/sqlite/files/CVE-2020-11655.patch b/poky/meta/recipes-support/sqlite/files/CVE-2020-11655.patch
deleted file mode 100644
index e30c482..0000000
--- a/poky/meta/recipes-support/sqlite/files/CVE-2020-11655.patch
+++ /dev/null
@@ -1,32 +0,0 @@
-From a4601326d61bf1a11151ac6b78b50804bfd03b4d Mon Sep 17 00:00:00 2001
-From: Sakib Sajal <sakib.sajal@windriver.com>
-Date: Thu, 30 Apr 2020 10:46:16 -0700
-Subject: [PATCH 2/2] In the event of a semantic error in an aggregate query,
- early-out the resetAccumulator() function to prevent problems due to
- incomplete or incorrect initialization of the AggInfo object. Fix for ticket
- [af4556bb5c285c08].
-
-FossilOrigin-Name: 4a302b42c7bf5e11ddb5522ca999f74aba397d3a7eb91b1844bb02852f772441
-Upstream Status: Backport [c415d91007e1680e4eb17def583b202c3c83c718]
-
-CVE: CVE-2020-11655
-Signed-off-by: Sakib Sajal <sakib.sajal@windriver.com>
----
- sqlite3.c | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/sqlite3.c b/sqlite3.c
-index 1df6633..726adf7 100644
---- a/sqlite3.c
-+++ b/sqlite3.c
-@@ -133242,6 +133242,7 @@ static void resetAccumulator(Parse *pParse, AggInfo *pAggInfo){
-   struct AggInfo_func *pFunc;
-   int nReg = pAggInfo->nFunc + pAggInfo->nColumn;
-   if( nReg==0 ) return;
-+  if( pParse->nErr ) return;
- #ifdef SQLITE_DEBUG
-   /* Verify that all AggInfo registers are within the range specified by
-   ** AggInfo.mnReg..AggInfo.mxReg */
--- 
-2.17.1
-
diff --git a/poky/meta/recipes-support/sqlite/files/CVE-2020-11656.patch b/poky/meta/recipes-support/sqlite/files/CVE-2020-11656.patch
deleted file mode 100644
index b88a724..0000000
--- a/poky/meta/recipes-support/sqlite/files/CVE-2020-11656.patch
+++ /dev/null
@@ -1,70 +0,0 @@
-From 2d69a520d027eb73eb6da9f2653d23e33b10e8bb Mon Sep 17 00:00:00 2001
-From: Sakib Sajal <sakib.sajal@windriver.com>
-Date: Thu, 30 Apr 2020 10:14:36 -0700
-Subject: [PATCH 1/2] Fix a case when a pointer might be used after
- being freed in  the ALTER TABLE code. Fix for [4722bdab08cb1].
-
-FossilOrigin-Name: d09f8c3621d5f7f8c6d99d7d82bcaa8421855b3f470bea2b26c858106382b906
-Upstream Status: Backport [fb99e388ec7f30fe43e4878236e3695ff24ae58d]
-
-[PATCH 2/2] Do not suppress errors when resolving references in an ORDER
- BY clause belonging to a compound SELECT within a view or trigger within
- ALTER TABLE. Fix for ticket [a10a14e9b4ba2].
-
-FossilOrigin-Name: 684293882c302600e112cf52553c19d84fdb31663d96e5dd7f8ac17dda00a026
-Upstream Status: Backport [4db7ab53f9c30e2e22731ace93ab6b18eef6c4ae]
-
-The two patches were converted to amalgamation format.
-
-CVE: CVE-2020-11656
-Signed-off-by: Sakib Sajal <sakib.sajal@windriver.com>
----
- sqlite3.c | 18 +++++++++++++++++-
- 1 file changed, 17 insertions(+), 1 deletion(-)
-
-diff --git a/sqlite3.c b/sqlite3.c
-index 64fae04..1df6633 100644
---- a/sqlite3.c
-+++ b/sqlite3.c
-@@ -97945,7 +97945,7 @@ static int resolveOrderByTermToExprList(
-   nc.nErr = 0;
-   db = pParse->db;
-   savedSuppErr = db->suppressErr;
--  db->suppressErr = 1;
-+  if( IN_RENAME_OBJECT==0 ) db->suppressErr = 1;
-   rc = sqlite3ResolveExprNames(&nc, pE);
-   db->suppressErr = savedSuppErr;
-   if( rc ) return 0;
-@@ -105383,6 +105383,21 @@ static void renameWalkWith(Walker *pWalker, Select *pSelect){
-   }
- }
- 
-+/*
-+** Unmap all tokens in the IdList object passed as the second argument.
-+*/
-+static void unmapColumnIdlistNames(
-+  Parse *pParse,
-+  IdList *pIdList
-+){
-+  if( pIdList ){
-+    int ii;
-+    for(ii=0; ii<pIdList->nId; ii++){
-+      sqlite3RenameTokenRemap(pParse, 0, (void*)pIdList->a[ii].zName);
-+    }
-+  }
-+}
-+
- /*
- ** Walker callback used by sqlite3RenameExprUnmap().
- */
-@@ -105404,6 +105419,7 @@ static int renameUnmapSelectCb(Walker *pWalker, Select *p){
-     for(i=0; i<pSrc->nSrc; i++){
-       sqlite3RenameTokenRemap(pParse, 0, (void*)pSrc->a[i].zName);
-       if( sqlite3WalkExpr(pWalker, pSrc->a[i].pOn) ) return WRC_Abort;
-+      unmapColumnIdlistNames(pParse, pSrc->a[i].pUsing);
-     }
-   }
- 
--- 
-2.17.1
-
diff --git a/poky/meta/recipes-support/sqlite/files/CVE-2020-9327.patch b/poky/meta/recipes-support/sqlite/files/CVE-2020-9327.patch
deleted file mode 100644
index fecbbab..0000000
--- a/poky/meta/recipes-support/sqlite/files/CVE-2020-9327.patch
+++ /dev/null
@@ -1,141 +0,0 @@
-From 45d491851e1bca378de158a5e279fd584ce548e4 Mon Sep 17 00:00:00 2001
-From: "D. Richard Hipp" <drh@hwaci.com>
-Date: Mon, 17 Feb 2020 00:12:04 +0000
-Subject: [PATCH] [PATCH 1/2]  Take care when checking the table of a TK_COLUMN
-  expression node to see if the table is a virtual table to first ensure that 
- the Expr.y.pTab pointer is not null due to generated column optimizations. 
- Ticket [4374860b29383380].
-
-FossilOrigin-Name: 9d0d4ab95dc0c56e053c2924ed322a9ea7b25439e6f74599f706905a1994e454
-
-[PATCH 2/2] A better (smaller and faster) solution to ticket
- [4374860b29383380].
-
-FossilOrigin-Name: abc473fb8fb999005dc79a360e34f97b3b25429decf1820dd2afa5c19577753d
-
-The two patches were converted to amalgamation format
-
-Signed-off-by: Anuj Mittal <anuj.mittal@intel.com>
-Upstream-Status: Backport
-CVE: CVE-2020-9327
----
- sqlite3.c | 35 ++++++++++++++++++++++++-----------
- sqlite3.h |  2 +-
- 2 files changed, 25 insertions(+), 12 deletions(-)
-
-diff --git a/sqlite3.c b/sqlite3.c
-index 55dc686..64fae04 100644
---- a/sqlite3.c
-+++ b/sqlite3.c
-@@ -1167,7 +1167,7 @@ extern "C" {
- */
- #define SQLITE_VERSION        "3.31.1"
- #define SQLITE_VERSION_NUMBER 3031001
--#define SQLITE_SOURCE_ID      "2020-01-27 19:55:54 3bfa9cc97da10598521b342961df8f5f68c7388fa117345eeb516eaa837bb4d6"
-+#define SQLITE_SOURCE_ID      "2020-01-27 19:55:54 3bfa9cc97da10598521b342961df8f5f68c7388fa117345eeb516eaa837balt1"
- 
- /*
- ** CAPI3REF: Run-Time Library Version Numbers
-@@ -17428,8 +17428,11 @@ struct Table {
- */
- #ifndef SQLITE_OMIT_VIRTUALTABLE
- #  define IsVirtual(X)      ((X)->nModuleArg)
-+#  define ExprIsVtab(X)  \
-+              ((X)->op==TK_COLUMN && (X)->y.pTab!=0 && (X)->y.pTab->nModuleArg)
- #else
- #  define IsVirtual(X)      0
-+#  define ExprIsVtab(X)     0
- #endif
- 
- /*
-@@ -104133,19 +104136,25 @@ static int impliesNotNullRow(Walker *pWalker, Expr *pExpr){
-     case TK_LT:
-     case TK_LE:
-     case TK_GT:
--    case TK_GE:
-+    case TK_GE: {
-+      Expr *pLeft = pExpr->pLeft;
-+      Expr *pRight = pExpr->pRight;
-       testcase( pExpr->op==TK_EQ );
-       testcase( pExpr->op==TK_NE );
-       testcase( pExpr->op==TK_LT );
-       testcase( pExpr->op==TK_LE );
-       testcase( pExpr->op==TK_GT );
-       testcase( pExpr->op==TK_GE );
--      if( (pExpr->pLeft->op==TK_COLUMN && IsVirtual(pExpr->pLeft->y.pTab))
--       || (pExpr->pRight->op==TK_COLUMN && IsVirtual(pExpr->pRight->y.pTab))
-+      /* The y.pTab=0 assignment in wherecode.c always happens after the
-+      ** impliesNotNullRow() test */
-+      if( (pLeft->op==TK_COLUMN && ALWAYS(pLeft->y.pTab!=0)
-+                               && IsVirtual(pLeft->y.pTab))
-+       || (pRight->op==TK_COLUMN && ALWAYS(pRight->y.pTab!=0)
-+                               && IsVirtual(pRight->y.pTab))
-       ){
--       return WRC_Prune;
-+        return WRC_Prune;
-       }
--
-+    }
-     default:
-       return WRC_Continue;
-   }
-@@ -142591,7 +142600,8 @@ static int isAuxiliaryVtabOperator(
-     **       MATCH(expression,vtab_column)
-     */
-     pCol = pList->a[1].pExpr;
--    if( pCol->op==TK_COLUMN && IsVirtual(pCol->y.pTab) ){
-+    testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
-+    if( ExprIsVtab(pCol) ){
-       for(i=0; i<ArraySize(aOp); i++){
-         if( sqlite3StrICmp(pExpr->u.zToken, aOp[i].zOp)==0 ){
-           *peOp2 = aOp[i].eOp2;
-@@ -142613,7 +142623,8 @@ static int isAuxiliaryVtabOperator(
-     ** with function names in an arbitrary case.
-     */
-     pCol = pList->a[0].pExpr;
--    if( pCol->op==TK_COLUMN && IsVirtual(pCol->y.pTab) ){
-+    testcase( pCol->op==TK_COLUMN && pCol->y.pTab==0 );
-+    if( ExprIsVtab(pCol) ){
-       sqlite3_vtab *pVtab;
-       sqlite3_module *pMod;
-       void (*xNotUsed)(sqlite3_context*,int,sqlite3_value**);
-@@ -142636,10 +142647,12 @@ static int isAuxiliaryVtabOperator(
-     int res = 0;
-     Expr *pLeft = pExpr->pLeft;
-     Expr *pRight = pExpr->pRight;
--    if( pLeft->op==TK_COLUMN && IsVirtual(pLeft->y.pTab) ){
-+    testcase( pLeft->op==TK_COLUMN && pLeft->y.pTab==0 );
-+    if( ExprIsVtab(pLeft) ){
-       res++;
-     }
--    if( pRight && pRight->op==TK_COLUMN && IsVirtual(pRight->y.pTab) ){
-+    testcase( pRight && pRight->op==TK_COLUMN && pRight->y.pTab==0 );
-+    if( pRight && ExprIsVtab(pRight) ){
-       res++;
-       SWAP(Expr*, pLeft, pRight);
-     }
-@@ -228440,7 +228453,7 @@ SQLITE_API int sqlite3_stmt_init(
- #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_STMTVTAB) */
- 
- /************** End of stmt.c ************************************************/
--#if __LINE__!=228443
-+#if __LINE__!=228456
- #undef SQLITE_SOURCE_ID
- #define SQLITE_SOURCE_ID      "2020-01-27 19:55:54 3bfa9cc97da10598521b342961df8f5f68c7388fa117345eeb516eaa837balt2"
- #endif
-diff --git a/sqlite3.h b/sqlite3.h
-index cef6eea..5b9796c 100644
---- a/sqlite3.h
-+++ b/sqlite3.h
-@@ -125,7 +125,7 @@ extern "C" {
- */
- #define SQLITE_VERSION        "3.31.1"
- #define SQLITE_VERSION_NUMBER 3031001
--#define SQLITE_SOURCE_ID      "2020-01-27 19:55:54 3bfa9cc97da10598521b342961df8f5f68c7388fa117345eeb516eaa837bb4d6"
-+#define SQLITE_SOURCE_ID      "2020-01-27 19:55:54 3bfa9cc97da10598521b342961df8f5f68c7388fa117345eeb516eaa837balt1"
- 
- /*
- ** CAPI3REF: Run-Time Library Version Numbers
--- 
-2.25.1
-
diff --git a/poky/meta/recipes-support/sqlite/sqlite3_3.31.1.bb b/poky/meta/recipes-support/sqlite/sqlite3_3.31.1.bb
deleted file mode 100644
index 57a7913..0000000
--- a/poky/meta/recipes-support/sqlite/sqlite3_3.31.1.bb
+++ /dev/null
@@ -1,15 +0,0 @@
-require sqlite3.inc
-
-LICENSE = "PD"
-LIC_FILES_CHKSUM = "file://sqlite3.h;endline=11;md5=786d3dc581eff03f4fd9e4a77ed00c66"
-
-SRC_URI = "http://www.sqlite.org/2020/sqlite-autoconf-${SQLITE_PV}.tar.gz \
-           file://CVE-2020-9327.patch \
-           file://CVE-2020-11656.patch \
-           file://CVE-2020-11655.patch \
-           "
-SRC_URI[md5sum] = "2d0a553534c521504e3ac3ad3b90f125"
-SRC_URI[sha256sum] = "62284efebc05a76f909c580ffa5c008a7d22a1287285d68b7825a2b6b51949ae"
-
-# -19242 is only an issue in specific development branch commits
-CVE_CHECK_WHITELIST += "CVE-2019-19242"
diff --git a/poky/meta/recipes-support/sqlite/sqlite3_3.32.1.bb b/poky/meta/recipes-support/sqlite/sqlite3_3.32.1.bb
new file mode 100644
index 0000000..d6081f1
--- /dev/null
+++ b/poky/meta/recipes-support/sqlite/sqlite3_3.32.1.bb
@@ -0,0 +1,11 @@
+require sqlite3.inc
+
+LICENSE = "PD"
+LIC_FILES_CHKSUM = "file://sqlite3.h;endline=11;md5=786d3dc581eff03f4fd9e4a77ed00c66"
+
+SRC_URI = "http://www.sqlite.org/2020/sqlite-autoconf-${SQLITE_PV}.tar.gz"
+SRC_URI[md5sum] = "bc7afc06f1e30b09ac930957af68d723"
+SRC_URI[sha256sum] = "486748abfb16abd8af664e3a5f03b228e5f124682b0c942e157644bf6fff7d10"
+
+# -19242 is only an issue in specific development branch commits
+CVE_CHECK_WHITELIST += "CVE-2019-19242"
diff --git a/poky/meta/recipes-support/vte/vte_0.60.2.bb b/poky/meta/recipes-support/vte/vte_0.60.2.bb
index 4a33f6e..8c70549 100644
--- a/poky/meta/recipes-support/vte/vte_0.60.2.bb
+++ b/poky/meta/recipes-support/vte/vte_0.60.2.bb
@@ -52,6 +52,9 @@
 
 PACKAGES =+ "libvte ${PN}-prompt"
 FILES_libvte = "${libdir}/*.so.* ${libdir}/girepository-1.0/*"
-FILES_${PN}-prompt = "${sysconfdir}/profile.d"
+FILES_${PN}-prompt = " \
+    ${sysconfdir}/profile.d \
+    ${libexecdir}/vte-urlencode-cwd \
+"
 
 BBCLASSEXTEND = "native nativesdk"
