5.4.70.40

PKGBUILD:
Upgrade to 5.4.70.40.
Add all patches in use for core/linux-lts.

5 files changed, 791 insertions, 20 deletions

diff --git a/.SRCINFO b/.SRCINFO
index 14d125718fad..21f31c08a1f2 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,6 +1,6 @@
 pkgbase = linux-rt-lts
 	pkgdesc = Linux RT LTS
-	pkgver = 5.4.69.39
+	pkgver = 5.4.70.40
 	pkgrel = 1
 	url = https://wiki.linuxfoundation.org/realtime/start
 	arch = x86_64
@@ -14,28 +14,34 @@ pkgbase = linux-rt-lts
 	makedepends = python-sphinx_rtd_theme
 	makedepends = xmlto
 	options = !strip
-	source = https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.4.69.tar.xz
-	source = https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.4.69.tar.sign
-	source = https://www.kernel.org/pub/linux/kernel/projects/rt/5.4/older/patch-5.4.69-rt39.patch.xz
-	source = https://www.kernel.org/pub/linux/kernel/projects/rt/5.4/older/patch-5.4.69-rt39.patch.sign
+	source = https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.4.70.tar.xz
+	source = https://www.kernel.org/pub/linux/kernel/v5.x/linux-5.4.70.tar.sign
+	source = https://www.kernel.org/pub/linux/kernel/projects/rt/5.4/older/patch-5.4.70-rt40.patch.xz
+	source = https://www.kernel.org/pub/linux/kernel/projects/rt/5.4/older/patch-5.4.70-rt40.patch.sign
 	source = config
 	source = 0001-ZEN-Add-sysctl-and-CONFIG-to-disallow-unprivileged-C.patch
+	source = 0002-virt-vbox-Add-support-for-the-new-VBG_IOCTL_ACQUIRE_.patch
+	source = 0003-i2c-core-Restore-acpi_walk_dep_device_list-getting-c.patch
 	source = sphinx-workaround.patch
 	validpgpkeys = 647F28654894E3BD457199BE38DBBDC86092693E
 	validpgpkeys = 5ED9A48FC54C0A22D1D0804CEBC26CDB5A56DE73
-	sha512sums = 3a161bce688b1e9d18703f6354b746d1e8c72dcbbf6e3c8759a98ef3611234a32d7e571977aa78f33db9d42cfd9ad82145f3faea028d335a1863eb624b940b6c
+	sha512sums = ab356476eb68ac1b2c172be97286418be307303e11ddd21e2d15cfa978a5d47b2bfec5cc61a306b48e0587e5b78cb02cec856981db9013112f4cd895374a5f21
 	sha512sums = SKIP
-	sha512sums = a811bd56dcf774c5fc1cd2f795c7594c173cf2f245463f2d047740317f69c66d82d097b2b98b5ee2c5c8ac4eb4de0a37954e24f7aaec2c9540b5192db93538a2
+	sha512sums = 9a325cbeaa783ddfc3e0ceafecebcf55caf65245d3beeac652db9793af064a0ab49608b2c39371ea33b058ae90fc427aeb6a300e27a716482f31a1c2226b6439
 	sha512sums = SKIP
-	sha512sums = 7b8912a045456502937d1fa7bcec5b072ed11d3effbe93ce959744cc36515cbcc82b785abafbe199aa7de3aae2fb30436e321619593546c508cfccae2ff2aaa8
+	sha512sums = addc00cb54d7fea6539a4b5a46b0e3d5dec9a967357bbddd09376a83647f740e2f4cea34de659550498834aafb57f3f450815119e2c4ed69dc5241838593d393
 	sha512sums = 5f196378d50dd737d727e424d8f31b7fa8a6b92ba88f0a1467ef79bc37a097160da1fc1fd5cfb4b8983f36f2afdf27eb229ec61b35a15ac2343d660eb416a230
+	sha512sums = 315aaf31af7b869ba64e324ab33ffa5050b761ecbd7aa6b9a900b8b2ca655d80f840fca9973d4f12ec067519ba4ab2ebdd41d518a9fda4586377ee9c9e9a2fda
+	sha512sums = 0f69e98f934bec92b6bea535241b6a7e21eba8df055c26f970c47e424b06053953737336de6f5b81266f30be211f27f9cbbf678aa4ec9fb968a3c290c9726ac1
 	sha512sums = 8081673a6594e5fc2fddc98fa434e99817aa822f7136d3c14c8d465fa7b93c9ac5d3a4150a5b632e25b1dc76a814dfa19d8aede37d58b935db288465b6585c58
-	b2sums = 8a9b8e44b5a1ae69a4422f22b31c48ea1cf0ccf4b7fe55baa8e68b4797f717b66b38f739a5e525455ce9ecf99fdf312275a856d7f6956f17f3ffbb10a749ab63
+	b2sums = 2db07e8ed76feba1dbbb697f959540ec7a050098022a460b4251802a99f71c01a76f9cbf81806cf4bd5b814a0e6b1e9f36364fcf099cf44d90780e6e0dc9ecfe
 	b2sums = SKIP
-	b2sums = 14a18a2802042a384e565d4583f194ede7a8b63bab368db1f51d79466552a53a9e485199d5a954ae47241d063a5d9ce72630c29af566284e8a35a4095787e29e
+	b2sums = 0f911652bedb74d40bfd42a2ef0e0b7309c31152f6d94a8cb6c91e0a16e8f5af007de6f3e41145b8c1248aba34f3ee90e024b40558de073419bb70e4d12749d9
 	b2sums = SKIP
-	b2sums = 1540f45b0b3639f646c823151884c36665894e486e7fb1706984ac795cf6f36f6abab812b38c27abc0921b7b689214c23d2e71bbaf6334187954f496353f500b
+	b2sums = c7811fb148f4353f8f90053d4746433c91456925c7d086c9af070bcd9c047530694a92a41ce1f1eb5606eb2968682e4a98b48a0b744b661fb982e67943c54d5e
 	b2sums = 3c3be0e85347bf3825f855a0a399ed60497cd0376f4b8ee1fe89df9bd90fe01cdd97fb3f4c4eea3918ba3769fc79961b6c58ba997326cbdf9dd7fb9540d8f6d6
+	b2sums = 4ca82850b654f94378fe6c35c1903830b7ca58dfd8c482a36b193edb78785e7a8cca146fa5aee9f372f14fd5e01e716cf74ec40e773b7e1327df64b768d7a3a2
+	b2sums = 4fdc4b2beb36fc042a1747e07863b12e762b30951eb3bfc012f440d5ea2217180bf5eff25bd48e90e3d4953bf4119f5e7a280095fa9138de79480eedbcc639b5
 	b2sums = 657fd0e70d29eee5518c27af7eec73a18f399215d2a21cf7b92c9914bee16d1e0981c00065ccb12f0534e57af906af63b17221c65a61146ec8894c88420fa56c
 
 pkgname = linux-rt-lts
diff --git a/0002-virt-vbox-Add-support-for-the-new-VBG_IOCTL_ACQUIRE_.patch b/0002-virt-vbox-Add-support-for-the-new-VBG_IOCTL_ACQUIRE_.patch
new file mode 100644
index 000000000000..ce36e014e9f7
--- /dev/null
+++ b/0002-virt-vbox-Add-support-for-the-new-VBG_IOCTL_ACQUIRE_.patch
@@ -0,0 +1,689 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "Jan Alexander Steffens (heftig)" <heftig@archlinux.org>
+Date: Wed, 15 Jul 2020 22:42:07 +0200
+Subject: [PATCH] virt: vbox: Add support for the new
+ VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES ioctl
+
+https://lore.kernel.org/patchwork/cover/1270301/
+
+Needed for https://bugs.archlinux.org/task/67253
+
+Squashed commit of the following:
+
+commit 0d7bec556896815f4920a5ed87339732c697175c
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:58 2020 +0200
+
+    virt: vbox: Fix some comments which talk about the "session spinlock"
+
+    The session lock is a mutex, not a spinlock, fix the comments to match.
+
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit fed91350029e0c3bf626bd55a148e766587ec439
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:57 2020 +0200
+
+    virt: vbox: Log unknown ioctl requests as error
+
+    Every now and then upstream adds new ioctls without notifying us,
+    log unknown ioctl requests as an error to catch these.
+
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit 245d06f4c1b8f84cde07d14c09296a4fe90a26f0
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:56 2020 +0200
+
+    virt: vbox: Add a few new vmmdev request types to the userspace whitelist
+
+    Upstream VirtualBox has defined and is using a few new request types for
+    vmmdev requests passed through /dev/vboxguest to the hypervisor.
+
+    Add the defines for these to vbox_vmmdev_types.h and add add them to the
+    whitelists of vmmdev requests which userspace is allowed to make.
+
+    BugLink: https://bugzilla.redhat.com/show_bug.cgi?id=1789545
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit 2f24f5446915322bbbb1ccf4ee2297512feab942
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:55 2020 +0200
+
+    virt: vbox: Add support for the new VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES ioctl
+
+    Add support for the new VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES ioctl, this
+    is necessary for automatic resizing of the guest resolution to match the
+    VM-window size to work with the new VMSVGA virtual GPU which is now the
+    new default in VirtualBox.
+
+    BugLink: https://bugzilla.redhat.com/show_bug.cgi?id=1789545
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit 2fc9822453e8dd215765cd2b28e5e6e26338829e
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:54 2020 +0200
+
+    virt: vbox: Add vbg_set_host_capabilities() helper function
+
+    Add vbg_set_host_capabilities() helper function,  this is a preparation
+    patch for adding support for the VBGL_IOCTL_GUEST_CAPS_ACQUIRE ioctl.
+
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit 1594daf929c8691849c00e49e4a1ed977048addc
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:53 2020 +0200
+
+    virt: vbox: Rename guest_caps struct members to set_guest_caps
+
+    Rename guest_caps[_tracker] struct members to set_guest_caps[_tracker]
+    this is a preparation patch for adding support for the
+    VBGL_IOCTL_GUEST_CAPS_ACQUIRE ioctl.
+
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit d7f3b7cec66d171cf5194ad37f647f4562da6ccc
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:52 2020 +0200
+
+    virt: vbox: Fix guest capabilities mask check
+
+    Check the passed in capabilities against VMMDEV_GUEST_CAPABILITIES_MASK
+    instead of against VMMDEV_EVENT_VALID_EVENT_MASK.
+    This tightens the allowed mask from 0x7ff to 0x7.
+
+    Fixes: 0ba002bc4393 ("virt: Add vboxguest driver for Virtual Box Guest integration")
+    Cc: stable@vger.kernel.org
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+
+commit f6694fa90e2183874def2d022d097795e2269a15
+Author: Hans de Goede <hdegoede@redhat.com>
+Date:   Thu Jul 9 14:08:51 2020 +0200
+
+    virt: vbox: Fix VBGL_IOCTL_VMMDEV_REQUEST_BIG and _LOG req numbers to match upstream
+
+    Until this commit the mainline kernel version (this version) of the
+    vboxguest module contained a bug where it defined
+    VBGL_IOCTL_VMMDEV_REQUEST_BIG and VBGL_IOCTL_LOG using
+    _IOC(_IOC_READ | _IOC_WRITE, 'V', ...) instead of
+    _IO(V, ...) as the out of tree VirtualBox upstream version does.
+
+    Since the VirtualBox userspace bits are always built against VirtualBox
+    upstream's headers, this means that so far the mainline kernel version
+    of the vboxguest module has been failing these 2 ioctls with -ENOTTY.
+    I guess that VBGL_IOCTL_VMMDEV_REQUEST_BIG is never used causing us to
+    not hit that one and sofar the vboxguest driver has failed to actually
+    log any log messages passed it through VBGL_IOCTL_LOG.
+
+    This commit changes the VBGL_IOCTL_VMMDEV_REQUEST_BIG and VBGL_IOCTL_LOG
+    defines to match the out of tree VirtualBox upstream vboxguest version,
+    while keeping compatibility with the old wrong request defines so as
+    to not break the kernel ABI in case someone has been using the old
+    request defines.
+
+    Fixes: f6ddd094f579 ("virt: Add vboxguest driver for Virtual Box Guest integration UAPI")
+    Cc: stable@vger.kernel.org
+    Acked-by: Arnd Bergmann <arnd@arndb.de>
+    Reviewed-by: Arnd Bergmann <arnd@arndb.de>
+    Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ drivers/virt/vboxguest/vboxguest_core.c  | 266 +++++++++++++++++++----
+ drivers/virt/vboxguest/vboxguest_core.h  |  23 +-
+ drivers/virt/vboxguest/vboxguest_utils.c |   1 +
+ include/linux/vbox_utils.h               |   1 +
+ include/uapi/linux/vbox_vmmdev_types.h   |   3 +
+ include/uapi/linux/vboxguest.h           |  24 ++
+ 6 files changed, 269 insertions(+), 49 deletions(-)
+
+diff --git a/drivers/virt/vboxguest/vboxguest_core.c b/drivers/virt/vboxguest/vboxguest_core.c
+index 95bfdb8ac8a2..f449fc366cf3 100644
+--- a/drivers/virt/vboxguest/vboxguest_core.c
++++ b/drivers/virt/vboxguest/vboxguest_core.c
+@@ -558,7 +558,7 @@ static int vbg_reset_host_event_filter(struct vbg_dev *gdev,
+  * Changes the event filter mask for the given session.
+  *
+  * This is called in response to VBG_IOCTL_CHANGE_FILTER_MASK as well as to
+- * do session cleanup. Takes the session spinlock.
++ * do session cleanup. Takes the session mutex.
+  *
+  * Return: 0 or negative errno value.
+  * @gdev:			The Guest extension device.
+@@ -661,78 +661,205 @@ static int vbg_reset_host_capabilities(struct vbg_dev *gdev)
+ }
+ 
+ /**
+- * Sets the guest capabilities for a session. Takes the session spinlock.
++ * Set guest capabilities on the host.
++ * Must be called with gdev->session_mutex hold.
++ * Return: 0 or negative errno value.
++ * @gdev:			The Guest extension device.
++ * @session:			The session.
++ * @session_termination:	Set if we're called by the session cleanup code.
++ */
++static int vbg_set_host_capabilities(struct vbg_dev *gdev,
++				     struct vbg_session *session,
++				     bool session_termination)
++{
++	struct vmmdev_mask *req;
++	u32 caps;
++	int rc;
++
++	WARN_ON(!mutex_is_locked(&gdev->session_mutex));
++
++	caps = gdev->acquired_guest_caps | gdev->set_guest_caps_tracker.mask;
++
++	if (gdev->guest_caps_host == caps)
++		return 0;
++
++	/* On termination the requestor is the kernel, as we're cleaning up. */
++	req = vbg_req_alloc(sizeof(*req), VMMDEVREQ_SET_GUEST_CAPABILITIES,
++			    session_termination ? VBG_KERNEL_REQUEST :
++						  session->requestor);
++	if (!req) {
++		gdev->guest_caps_host = U32_MAX;
++		return -ENOMEM;
++	}
++
++	req->or_mask = caps;
++	req->not_mask = ~caps;
++	rc = vbg_req_perform(gdev, req);
++	vbg_req_free(req, sizeof(*req));
++
++	gdev->guest_caps_host = (rc >= 0) ? caps : U32_MAX;
++
++	return vbg_status_code_to_errno(rc);
++}
++
++/**
++ * Acquire (get exclusive access) guest capabilities for a session.
++ * Takes the session mutex.
++ * Return: 0 or negative errno value.
++ * @gdev:			The Guest extension device.
++ * @session:			The session.
++ * @flags:			Flags (VBGL_IOC_AGC_FLAGS_XXX).
++ * @or_mask:			The capabilities to add.
++ * @not_mask:			The capabilities to remove.
++ * @session_termination:	Set if we're called by the session cleanup code.
++ *				This tweaks the error handling so we perform
++ *				proper session cleanup even if the host
++ *				misbehaves.
++ */
++static int vbg_acquire_session_capabilities(struct vbg_dev *gdev,
++					    struct vbg_session *session,
++					    u32 or_mask, u32 not_mask,
++					    u32 flags, bool session_termination)
++{
++	unsigned long irqflags;
++	bool wakeup = false;
++	int ret = 0;
++
++	mutex_lock(&gdev->session_mutex);
++
++	if (gdev->set_guest_caps_tracker.mask & or_mask) {
++		vbg_err("%s error: cannot acquire caps which are currently set\n",
++			__func__);
++		ret = -EINVAL;
++		goto out;
++	}
++
++	/*
++	 * Mark any caps in the or_mask as now being in acquire-mode. Note
++	 * once caps are in acquire_mode they always stay in this mode.
++	 * This impacts event handling, so we take the event-lock.
++	 */
++	spin_lock_irqsave(&gdev->event_spinlock, irqflags);
++	gdev->acquire_mode_guest_caps |= or_mask;
++	spin_unlock_irqrestore(&gdev->event_spinlock, irqflags);
++
++	/* If we only have to switch the caps to acquire mode, we're done. */
++	if (flags & VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE)
++		goto out;
++
++	not_mask &= ~or_mask; /* or_mask takes priority over not_mask */
++	not_mask &= session->acquired_guest_caps;
++	or_mask &= ~session->acquired_guest_caps;
++
++	if (or_mask == 0 && not_mask == 0)
++		goto out;
++
++	if (gdev->acquired_guest_caps & or_mask) {
++		ret = -EBUSY;
++		goto out;
++	}
++
++	gdev->acquired_guest_caps |= or_mask;
++	gdev->acquired_guest_caps &= ~not_mask;
++	/* session->acquired_guest_caps impacts event handling, take the lock */
++	spin_lock_irqsave(&gdev->event_spinlock, irqflags);
++	session->acquired_guest_caps |= or_mask;
++	session->acquired_guest_caps &= ~not_mask;
++	spin_unlock_irqrestore(&gdev->event_spinlock, irqflags);
++
++	ret = vbg_set_host_capabilities(gdev, session, session_termination);
++	/* Roll back on failure, unless it's session termination time. */
++	if (ret < 0 && !session_termination) {
++		gdev->acquired_guest_caps &= ~or_mask;
++		gdev->acquired_guest_caps |= not_mask;
++		spin_lock_irqsave(&gdev->event_spinlock, irqflags);
++		session->acquired_guest_caps &= ~or_mask;
++		session->acquired_guest_caps |= not_mask;
++		spin_unlock_irqrestore(&gdev->event_spinlock, irqflags);
++	}
++
++	/*
++	 * If we added a capability, check if that means some other thread in
++	 * our session should be unblocked because there are events pending
++	 * (the result of vbg_get_allowed_event_mask_for_session() may change).
++	 *
++	 * HACK ALERT! When the seamless support capability is added we generate
++	 *	a seamless change event so that the ring-3 client can sync with
++	 *	the seamless state.
++	 */
++	if (ret == 0 && or_mask != 0) {
++		spin_lock_irqsave(&gdev->event_spinlock, irqflags);
++
++		if (or_mask & VMMDEV_GUEST_SUPPORTS_SEAMLESS)
++			gdev->pending_events |=
++				VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
++
++		if (gdev->pending_events)
++			wakeup = true;
++
++		spin_unlock_irqrestore(&gdev->event_spinlock, irqflags);
++
++		if (wakeup)
++			wake_up(&gdev->event_wq);
++	}
++
++out:
++	mutex_unlock(&gdev->session_mutex);
++
++	return ret;
++}
++
++/**
++ * Sets the guest capabilities for a session. Takes the session mutex.
+  * Return: 0 or negative errno value.
+  * @gdev:			The Guest extension device.
+  * @session:			The session.
+  * @or_mask:			The capabilities to add.
+  * @not_mask:			The capabilities to remove.
+  * @session_termination:	Set if we're called by the session cleanup code.
+  *				This tweaks the error handling so we perform
+  *				proper session cleanup even if the host
+  *				misbehaves.
+  */
+ static int vbg_set_session_capabilities(struct vbg_dev *gdev,
+ 					struct vbg_session *session,
+ 					u32 or_mask, u32 not_mask,
+ 					bool session_termination)
+ {
+-	struct vmmdev_mask *req;
+ 	u32 changed, previous;
+-	int rc, ret = 0;
+-
+-	/*
+-	 * Allocate a request buffer before taking the spinlock, when
+-	 * the session is being terminated the requestor is the kernel,
+-	 * as we're cleaning up.
+-	 */
+-	req = vbg_req_alloc(sizeof(*req), VMMDEVREQ_SET_GUEST_CAPABILITIES,
+-			    session_termination ? VBG_KERNEL_REQUEST :
+-						  session->requestor);
+-	if (!req) {
+-		if (!session_termination)
+-			return -ENOMEM;
+-		/* Ignore allocation failure, we must do session cleanup. */
+-	}
++	int ret = 0;
+ 
+ 	mutex_lock(&gdev->session_mutex);
+ 
++	if (gdev->acquire_mode_guest_caps & or_mask) {
++		vbg_err("%s error: cannot set caps which are in acquire_mode\n",
++			__func__);
++		ret = -EBUSY;
++		goto out;
++	}
++
+ 	/* Apply the changes to the session mask. */
+-	previous = session->guest_caps;
+-	session->guest_caps |= or_mask;
+-	session->guest_caps &= ~not_mask;
++	previous = session->set_guest_caps;
++	session->set_guest_caps |= or_mask;
++	session->set_guest_caps &= ~not_mask;
+ 
+ 	/* If anything actually changed, update the global usage counters. */
+-	changed = previous ^ session->guest_caps;
++	changed = previous ^ session->set_guest_caps;
+ 	if (!changed)
+ 		goto out;
+ 
+-	vbg_track_bit_usage(&gdev->guest_caps_tracker, changed, previous);
+-	or_mask = gdev->guest_caps_tracker.mask;
++	vbg_track_bit_usage(&gdev->set_guest_caps_tracker, changed, previous);
+ 
+-	if (gdev->guest_caps_host == or_mask || !req)
+-		goto out;
+-
+-	gdev->guest_caps_host = or_mask;
+-	req->or_mask = or_mask;
+-	req->not_mask = ~or_mask;
+-	rc = vbg_req_perform(gdev, req);
+-	if (rc < 0) {
+-		ret = vbg_status_code_to_errno(rc);
+-
+-		/* Failed, roll back (unless it's session termination time). */
+-		gdev->guest_caps_host = U32_MAX;
+-		if (session_termination)
+-			goto out;
+-
+-		vbg_track_bit_usage(&gdev->guest_caps_tracker, changed,
+-				    session->guest_caps);
+-		session->guest_caps = previous;
++	ret = vbg_set_host_capabilities(gdev, session, session_termination);
++	/* Roll back on failure, unless it's session termination time. */
++	if (ret < 0 && !session_termination) {
++		vbg_track_bit_usage(&gdev->set_guest_caps_tracker, changed,
++				    session->set_guest_caps);
++		session->set_guest_caps = previous;
+ 	}
+ 
+ out:
+ 	mutex_unlock(&gdev->session_mutex);
+-	vbg_req_free(req, sizeof(*req));
+ 
+ 	return ret;
+ }
+@@ -948,6 +1075,7 @@ void vbg_core_close_session(struct vbg_session *session)
+ 	struct vbg_dev *gdev = session->gdev;
+ 	int i, rc;
+ 
++	vbg_acquire_session_capabilities(gdev, session, 0, U32_MAX, 0, true);
+ 	vbg_set_session_capabilities(gdev, session, 0, U32_MAX, true);
+ 	vbg_set_session_event_filter(gdev, session, 0, U32_MAX, true);
+ 
+@@ -1005,31 +1133,52 @@ static int vbg_ioctl_driver_version_info(
+ 	return 0;
+ }
+ 
++/* Must be called with the event_lock held */
++static u32 vbg_get_allowed_event_mask_for_session(struct vbg_dev *gdev,
++						  struct vbg_session *session)
++{
++	u32 acquire_mode_caps = gdev->acquire_mode_guest_caps;
++	u32 session_acquired_caps = session->acquired_guest_caps;
++	u32 allowed_events = VMMDEV_EVENT_VALID_EVENT_MASK;
++
++	if ((acquire_mode_caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS) &&
++	    !(session_acquired_caps & VMMDEV_GUEST_SUPPORTS_GRAPHICS))
++		allowed_events &= ~VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST;
++
++	if ((acquire_mode_caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS) &&
++	    !(session_acquired_caps & VMMDEV_GUEST_SUPPORTS_SEAMLESS))
++		allowed_events &= ~VMMDEV_EVENT_SEAMLESS_MODE_CHANGE_REQUEST;
++
++	return allowed_events;
++}
++
+ static bool vbg_wait_event_cond(struct vbg_dev *gdev,
+ 				struct vbg_session *session,
+ 				u32 event_mask)
+ {
+ 	unsigned long flags;
+ 	bool wakeup;
+ 	u32 events;
+ 
+ 	spin_lock_irqsave(&gdev->event_spinlock, flags);
+ 
+ 	events = gdev->pending_events & event_mask;
++	events &= vbg_get_allowed_event_mask_for_session(gdev, session);
+ 	wakeup = events || session->cancel_waiters;
+ 
+ 	spin_unlock_irqrestore(&gdev->event_spinlock, flags);
+ 
+ 	return wakeup;
+ }
+ 
+ /* Must be called with the event_lock held */
+ static u32 vbg_consume_events_locked(struct vbg_dev *gdev,
+ 				     struct vbg_session *session,
+ 				     u32 event_mask)
+ {
+ 	u32 events = gdev->pending_events & event_mask;
+ 
++	events &= vbg_get_allowed_event_mask_for_session(gdev, session);
+ 	gdev->pending_events &= ~events;
+ 	return events;
+ }
+@@ -1149,7 +1298,9 @@ static int vbg_req_allowed(struct vbg_dev *gdev, struct vbg_session *session,
+ 	case VMMDEVREQ_VIDEO_ACCEL_ENABLE:
+ 	case VMMDEVREQ_VIDEO_ACCEL_FLUSH:
+ 	case VMMDEVREQ_VIDEO_SET_VISIBLE_REGION:
++	case VMMDEVREQ_VIDEO_UPDATE_MONITOR_POSITIONS:
+ 	case VMMDEVREQ_GET_DISPLAY_CHANGE_REQEX:
++	case VMMDEVREQ_GET_DISPLAY_CHANGE_REQ_MULTI:
+ 	case VMMDEVREQ_GET_SEAMLESS_CHANGE_REQ:
+ 	case VMMDEVREQ_GET_VRDPCHANGE_REQ:
+ 	case VMMDEVREQ_LOG_STRING:
+@@ -1431,27 +1582,50 @@ static int vbg_ioctl_change_filter_mask(struct vbg_dev *gdev,
+ 					    false);
+ }
+ 
++static int vbg_ioctl_acquire_guest_capabilities(struct vbg_dev *gdev,
++	     struct vbg_session *session,
++	     struct vbg_ioctl_acquire_guest_caps *caps)
++{
++	u32 flags, or_mask, not_mask;
++
++	if (vbg_ioctl_chk(&caps->hdr, sizeof(caps->u.in), 0))
++		return -EINVAL;
++
++	flags = caps->u.in.flags;
++	or_mask = caps->u.in.or_mask;
++	not_mask = caps->u.in.not_mask;
++
++	if (flags & ~VBGL_IOC_AGC_FLAGS_VALID_MASK)
++		return -EINVAL;
++
++	if ((or_mask | not_mask) & ~VMMDEV_GUEST_CAPABILITIES_MASK)
++		return -EINVAL;
++
++	return vbg_acquire_session_capabilities(gdev, session, or_mask,
++						not_mask, flags, false);
++}
++
+ static int vbg_ioctl_change_guest_capabilities(struct vbg_dev *gdev,
+ 	     struct vbg_session *session, struct vbg_ioctl_set_guest_caps *caps)
+ {
+ 	u32 or_mask, not_mask;
+ 	int ret;
+ 
+ 	if (vbg_ioctl_chk(&caps->hdr, sizeof(caps->u.in), sizeof(caps->u.out)))
+ 		return -EINVAL;
+ 
+ 	or_mask = caps->u.in.or_mask;
+ 	not_mask = caps->u.in.not_mask;
+ 
+ 	if ((or_mask | not_mask) & ~VMMDEV_GUEST_CAPABILITIES_MASK)
+ 		return -EINVAL;
+ 
+ 	ret = vbg_set_session_capabilities(gdev, session, or_mask, not_mask,
+ 					   false);
+ 	if (ret)
+ 		return ret;
+ 
+-	caps->u.out.session_caps = session->guest_caps;
++	caps->u.out.session_caps = session->set_guest_caps;
+ 	caps->u.out.global_caps = gdev->guest_caps_host;
+ 
+ 	return 0;
+@@ -1540,29 +1714,31 @@ int vbg_core_ioctl(struct vbg_session *session, unsigned int req, void *data)
+ 		return vbg_ioctl_interrupt_all_wait_events(gdev, session, data);
+ 	case VBG_IOCTL_CHANGE_FILTER_MASK:
+ 		return vbg_ioctl_change_filter_mask(gdev, session, data);
++	case VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES:
++		return vbg_ioctl_acquire_guest_capabilities(gdev, session, data);
+ 	case VBG_IOCTL_CHANGE_GUEST_CAPABILITIES:
+ 		return vbg_ioctl_change_guest_capabilities(gdev, session, data);
+ 	case VBG_IOCTL_CHECK_BALLOON:
+ 		return vbg_ioctl_check_balloon(gdev, data);
+ 	case VBG_IOCTL_WRITE_CORE_DUMP:
+ 		return vbg_ioctl_write_core_dump(gdev, session, data);
+ 	}
+ 
+ 	/* Variable sized requests. */
+ 	switch (req_no_size) {
+ #ifdef CONFIG_COMPAT
+ 	case VBG_IOCTL_HGCM_CALL_32(0):
+ 		f32bit = true;
+ #endif
+ 		/* Fall through */
+ 	case VBG_IOCTL_HGCM_CALL(0):
+ 		return vbg_ioctl_hgcm_call(gdev, session, f32bit, data);
+ 	case VBG_IOCTL_LOG(0):
+ 	case VBG_IOCTL_LOG_ALT(0):
+ 		return vbg_ioctl_log(data);
+ 	}
+ 
+-	vbg_debug("VGDrvCommonIoCtl: Unknown req %#08x\n", req);
++	vbg_err_ratelimited("Userspace made an unknown ioctl req %#08x\n", req);
+ 	return -ENOTTY;
+ }
+ 
+diff --git a/drivers/virt/vboxguest/vboxguest_core.h b/drivers/virt/vboxguest/vboxguest_core.h
+index 77c3a9c8255d..ab4bf64e2cec 100644
+--- a/drivers/virt/vboxguest/vboxguest_core.h
++++ b/drivers/virt/vboxguest/vboxguest_core.h
+@@ -118,11 +118,21 @@ struct vbg_dev {
+ 	u32 event_filter_host;
+ 
+ 	/**
+-	 * Usage counters for guest capabilities. Indexed by capability bit
++	 * Guest capabilities which have been switched to acquire_mode.
++	 */
++	u32 acquire_mode_guest_caps;
++	/**
++	 * Guest capabilities acquired by vbg_acquire_session_capabilities().
++	 * Only one session can acquire a capability at a time.
++	 */
++	u32 acquired_guest_caps;
++	/**
++	 * Usage counters for guest capabilities requested through
++	 * vbg_set_session_capabilities(). Indexed by capability bit
+ 	 * number, one count per session using a capability.
+ 	 * Protected by session_mutex.
+ 	 */
+-	struct vbg_bit_usage_tracker guest_caps_tracker;
++	struct vbg_bit_usage_tracker set_guest_caps_tracker;
+ 	/**
+ 	 * The guest capabilities last reported to the host (or UINT32_MAX).
+ 	 * Protected by session_mutex.
+@@ -164,11 +174,16 @@ struct vbg_session {
+ 	 */
+ 	u32 event_filter;
+ 	/**
+-	 * Guest capabilities for this session.
++	 * Guest capabilities acquired by vbg_acquire_session_capabilities().
++	 * Only one session can acquire a capability at a time.
++	 */
++	u32 acquired_guest_caps;
++	/**
++	 * Guest capabilities set through vbg_set_session_capabilities().
+ 	 * A capability claimed by any guest session will be reported to the
+ 	 * host. Protected by vbg_gdev.session_mutex.
+ 	 */
+-	u32 guest_caps;
++	u32 set_guest_caps;
+ 	/** VMMDEV_REQUESTOR_* flags */
+ 	u32 requestor;
+ 	/** Set on CANCEL_ALL_WAITEVENTS, protected by vbg_devevent_spinlock. */
+diff --git a/drivers/virt/vboxguest/vboxguest_utils.c b/drivers/virt/vboxguest/vboxguest_utils.c
+index 43c391626a00..b6fd06eb015e 100644
+--- a/drivers/virt/vboxguest/vboxguest_utils.c
++++ b/drivers/virt/vboxguest/vboxguest_utils.c
+@@ -58,6 +58,7 @@ EXPORT_SYMBOL(name)
+ VBG_LOG(vbg_info, pr_info);
+ VBG_LOG(vbg_warn, pr_warn);
+ VBG_LOG(vbg_err, pr_err);
++VBG_LOG(vbg_err_ratelimited, pr_err_ratelimited);
+ #if defined(DEBUG) && !defined(CONFIG_DYNAMIC_DEBUG)
+ VBG_LOG(vbg_debug, pr_debug);
+ #endif
+diff --git a/include/linux/vbox_utils.h b/include/linux/vbox_utils.h
+index ff56c443180c..db8a7d118093 100644
+--- a/include/linux/vbox_utils.h
++++ b/include/linux/vbox_utils.h
+@@ -16,6 +16,7 @@ struct vbg_dev;
+ __printf(1, 2) void vbg_info(const char *fmt, ...);
+ __printf(1, 2) void vbg_warn(const char *fmt, ...);
+ __printf(1, 2) void vbg_err(const char *fmt, ...);
++__printf(1, 2) void vbg_err_ratelimited(const char *fmt, ...);
+ 
+ /* Only use backdoor logging for non-dynamic debug builds */
+ #if defined(DEBUG) && !defined(CONFIG_DYNAMIC_DEBUG)
+diff --git a/include/uapi/linux/vbox_vmmdev_types.h b/include/uapi/linux/vbox_vmmdev_types.h
+index c27289fd619a..f8a8d6b3c521 100644
+--- a/include/uapi/linux/vbox_vmmdev_types.h
++++ b/include/uapi/linux/vbox_vmmdev_types.h
+@@ -63,6 +63,7 @@ enum vmmdev_request_type {
+ 	VMMDEVREQ_SET_GUEST_CAPABILITIES       = 56,
+ 	VMMDEVREQ_VIDEMODE_SUPPORTED2          = 57, /* since version 3.2.0 */
+ 	VMMDEVREQ_GET_DISPLAY_CHANGE_REQEX     = 80, /* since version 4.2.4 */
++	VMMDEVREQ_GET_DISPLAY_CHANGE_REQ_MULTI = 81,
+ 	VMMDEVREQ_HGCM_CONNECT                 = 60,
+ 	VMMDEVREQ_HGCM_DISCONNECT              = 61,
+ 	VMMDEVREQ_HGCM_CALL32                  = 62,
+@@ -92,6 +93,8 @@ enum vmmdev_request_type {
+ 	VMMDEVREQ_WRITE_COREDUMP               = 218,
+ 	VMMDEVREQ_GUEST_HEARTBEAT              = 219,
+ 	VMMDEVREQ_HEARTBEAT_CONFIGURE          = 220,
++	VMMDEVREQ_NT_BUG_CHECK                 = 221,
++	VMMDEVREQ_VIDEO_UPDATE_MONITOR_POSITIONS = 222,
+ 	/* Ensure the enum is a 32 bit data-type */
+ 	VMMDEVREQ_SIZEHACK                     = 0x7fffffff
+ };
+diff --git a/include/uapi/linux/vboxguest.h b/include/uapi/linux/vboxguest.h
+index f79d7abe27db..15125f6ec60d 100644
+--- a/include/uapi/linux/vboxguest.h
++++ b/include/uapi/linux/vboxguest.h
+@@ -257,6 +257,30 @@ VMMDEV_ASSERT_SIZE(vbg_ioctl_change_filter, 24 + 8);
+ 	_IOWR('V', 12, struct vbg_ioctl_change_filter)
+ 
+ 
++/** VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES data structure. */
++struct vbg_ioctl_acquire_guest_caps {
++	/** The header. */
++	struct vbg_ioctl_hdr hdr;
++	union {
++		struct {
++			/** Flags (VBGL_IOC_AGC_FLAGS_XXX). */
++			__u32 flags;
++			/** Capabilities to set (VMMDEV_GUEST_SUPPORTS_XXX). */
++			__u32 or_mask;
++			/** Capabilities to drop (VMMDEV_GUEST_SUPPORTS_XXX). */
++			__u32 not_mask;
++		} in;
++	} u;
++};
++VMMDEV_ASSERT_SIZE(vbg_ioctl_acquire_guest_caps, 24 + 12);
++
++#define VBGL_IOC_AGC_FLAGS_CONFIG_ACQUIRE_MODE		0x00000001
++#define VBGL_IOC_AGC_FLAGS_VALID_MASK			0x00000001
++
++#define VBG_IOCTL_ACQUIRE_GUEST_CAPABILITIES \
++	_IOWR('V', 13, struct vbg_ioctl_acquire_guest_caps)
++
++
+ /** VBG_IOCTL_CHANGE_GUEST_CAPABILITIES data structure. */
+ struct vbg_ioctl_set_guest_caps {
+ 	/** The header. */
diff --git a/0003-i2c-core-Restore-acpi_walk_dep_device_list-getting-c.patch b/0003-i2c-core-Restore-acpi_walk_dep_device_list-getting-c.patch
new file mode 100644
index 000000000000..a3d364b3e062
--- /dev/null
+++ b/0003-i2c-core-Restore-acpi_walk_dep_device_list-getting-c.patch
@@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Hans de Goede <hdegoede@redhat.com>
+Date: Wed, 14 Oct 2020 16:41:58 +0200
+Subject: [PATCH] i2c: core: Restore acpi_walk_dep_device_list() getting called
+ after registering the ACPI i2c devs
+
+Commit 21653a4181ff ("i2c: core: Call i2c_acpi_install_space_handler()
+before i2c_acpi_register_devices()")'s intention was to only move the
+acpi_install_address_space_handler() call to the point before where
+the ACPI declared i2c-children of the adapter where instantiated by
+i2c_acpi_register_devices().
+
+But i2c_acpi_install_space_handler() had a call to
+acpi_walk_dep_device_list() hidden (that is I missed it) at the end
+of it, so as an unwanted side-effect now acpi_walk_dep_device_list()
+was also being called before i2c_acpi_register_devices().
+
+Move the acpi_walk_dep_device_list() call to the end of
+i2c_acpi_register_devices(), so that it is once again called *after*
+the i2c_client-s hanging of the adapter have been created.
+
+This fixes the Microsoft Surface Go 2 hanging at boot.
+
+Fixes: 21653a4181ff ("i2c: core: Call i2c_acpi_install_space_handler() before i2c_acpi_register_devices()")
+Suggested-by: Maximilian Luz <luzmaximilian@gmail.com>
+Reported-and-tested-by: Kieran Bingham <kieran.bingham@ideasonboard.com>
+Signed-off-by: Hans de Goede <hdegoede@redhat.com>
+---
+ drivers/i2c/i2c-core-acpi.c | 11 ++++++++++-
+ 1 file changed, 10 insertions(+), 1 deletion(-)
+
+diff --git a/drivers/i2c/i2c-core-acpi.c b/drivers/i2c/i2c-core-acpi.c
+index ce70b5288472..c70983780ae7 100644
+--- a/drivers/i2c/i2c-core-acpi.c
++++ b/drivers/i2c/i2c-core-acpi.c
+@@ -264,16 +264,26 @@ static acpi_status i2c_acpi_add_device(acpi_handle handle, u32 level,
+ void i2c_acpi_register_devices(struct i2c_adapter *adap)
+ {
+ 	acpi_status status;
++	acpi_handle handle;
+ 
+ 	if (!has_acpi_companion(&adap->dev))
+ 		return;
+ 
+ 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
+ 				     I2C_ACPI_MAX_SCAN_DEPTH,
+ 				     i2c_acpi_add_device, NULL,
+ 				     adap, NULL);
+ 	if (ACPI_FAILURE(status))
+ 		dev_warn(&adap->dev, "failed to enumerate I2C slaves\n");
++
++	if (!adap->dev.parent)
++		return;
++
++	handle = ACPI_HANDLE(adap->dev.parent);
++	if (!handle)
++		return;
++
++	acpi_walk_dep_device_list(handle);
+ }
+ 
+ const struct acpi_device_id *
+@@ -737,7 +747,6 @@ int i2c_acpi_install_space_handler(struct i2c_adapter *adapter)
+ 		return -ENOMEM;
+ 	}
+ 
+-	acpi_walk_dep_device_list(handle);
+ 	return 0;
+ }
+ 
diff --git a/PKGBUILD b/PKGBUILD
index 9e7b20b4a60d..926241c7b910 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,8 +1,8 @@
 # Maintainer:  Joakim Hernberg <jbh@alchemy.lu>
 # Contributor: David Runge <dvzrv@archlinux.org>
 
-_pkgver=5.4.69
-_rtpatchver=39
+_pkgver=5.4.70
+_rtpatchver=40
 pkgbase=linux-rt-lts
 pkgver=${_pkgver}.${_rtpatchver}
 pkgrel=1
@@ -19,21 +19,27 @@ source=(
   "https://www.kernel.org/pub/linux/kernel/projects/rt/${_pkgver%.*}/older/patch-${_pkgver}-rt${_rtpatchver}.patch."{xz,sign}
   'config'
   '0001-ZEN-Add-sysctl-and-CONFIG-to-disallow-unprivileged-C.patch'
+  0002-virt-vbox-Add-support-for-the-new-VBG_IOCTL_ACQUIRE_.patch
+  0003-i2c-core-Restore-acpi_walk_dep_device_list-getting-c.patch
   'sphinx-workaround.patch'
 )
-sha512sums=('3a161bce688b1e9d18703f6354b746d1e8c72dcbbf6e3c8759a98ef3611234a32d7e571977aa78f33db9d42cfd9ad82145f3faea028d335a1863eb624b940b6c'
+sha512sums=('ab356476eb68ac1b2c172be97286418be307303e11ddd21e2d15cfa978a5d47b2bfec5cc61a306b48e0587e5b78cb02cec856981db9013112f4cd895374a5f21'
             'SKIP'
-            'a811bd56dcf774c5fc1cd2f795c7594c173cf2f245463f2d047740317f69c66d82d097b2b98b5ee2c5c8ac4eb4de0a37954e24f7aaec2c9540b5192db93538a2'
+            '9a325cbeaa783ddfc3e0ceafecebcf55caf65245d3beeac652db9793af064a0ab49608b2c39371ea33b058ae90fc427aeb6a300e27a716482f31a1c2226b6439'
             'SKIP'
-            '7b8912a045456502937d1fa7bcec5b072ed11d3effbe93ce959744cc36515cbcc82b785abafbe199aa7de3aae2fb30436e321619593546c508cfccae2ff2aaa8'
+            'addc00cb54d7fea6539a4b5a46b0e3d5dec9a967357bbddd09376a83647f740e2f4cea34de659550498834aafb57f3f450815119e2c4ed69dc5241838593d393'
             '5f196378d50dd737d727e424d8f31b7fa8a6b92ba88f0a1467ef79bc37a097160da1fc1fd5cfb4b8983f36f2afdf27eb229ec61b35a15ac2343d660eb416a230'
+            '315aaf31af7b869ba64e324ab33ffa5050b761ecbd7aa6b9a900b8b2ca655d80f840fca9973d4f12ec067519ba4ab2ebdd41d518a9fda4586377ee9c9e9a2fda'
+            '0f69e98f934bec92b6bea535241b6a7e21eba8df055c26f970c47e424b06053953737336de6f5b81266f30be211f27f9cbbf678aa4ec9fb968a3c290c9726ac1'
             '8081673a6594e5fc2fddc98fa434e99817aa822f7136d3c14c8d465fa7b93c9ac5d3a4150a5b632e25b1dc76a814dfa19d8aede37d58b935db288465b6585c58')
-b2sums=('8a9b8e44b5a1ae69a4422f22b31c48ea1cf0ccf4b7fe55baa8e68b4797f717b66b38f739a5e525455ce9ecf99fdf312275a856d7f6956f17f3ffbb10a749ab63'
+b2sums=('2db07e8ed76feba1dbbb697f959540ec7a050098022a460b4251802a99f71c01a76f9cbf81806cf4bd5b814a0e6b1e9f36364fcf099cf44d90780e6e0dc9ecfe'
         'SKIP'
-        '14a18a2802042a384e565d4583f194ede7a8b63bab368db1f51d79466552a53a9e485199d5a954ae47241d063a5d9ce72630c29af566284e8a35a4095787e29e'
+        '0f911652bedb74d40bfd42a2ef0e0b7309c31152f6d94a8cb6c91e0a16e8f5af007de6f3e41145b8c1248aba34f3ee90e024b40558de073419bb70e4d12749d9'
         'SKIP'
-        '1540f45b0b3639f646c823151884c36665894e486e7fb1706984ac795cf6f36f6abab812b38c27abc0921b7b689214c23d2e71bbaf6334187954f496353f500b'
+        'c7811fb148f4353f8f90053d4746433c91456925c7d086c9af070bcd9c047530694a92a41ce1f1eb5606eb2968682e4a98b48a0b744b661fb982e67943c54d5e'
         '3c3be0e85347bf3825f855a0a399ed60497cd0376f4b8ee1fe89df9bd90fe01cdd97fb3f4c4eea3918ba3769fc79961b6c58ba997326cbdf9dd7fb9540d8f6d6'
+        '4ca82850b654f94378fe6c35c1903830b7ca58dfd8c482a36b193edb78785e7a8cca146fa5aee9f372f14fd5e01e716cf74ec40e773b7e1327df64b768d7a3a2'
+        '4fdc4b2beb36fc042a1747e07863b12e762b30951eb3bfc012f440d5ea2217180bf5eff25bd48e90e3d4953bf4119f5e7a280095fa9138de79480eedbcc639b5'
         '657fd0e70d29eee5518c27af7eec73a18f399215d2a21cf7b92c9914bee16d1e0981c00065ccb12f0534e57af906af63b17221c65a61146ec8894c88420fa56c')
 validpgpkeys=(
   '647F28654894E3BD457199BE38DBBDC86092693E'  # Greg Kroah-Hartman <gregkh@linuxfoundation.org>
diff --git a/config b/config
index 8552322d6a20..a0d1c8577c7e 100644
--- a/config
+++ b/config
@@ -1,6 +1,6 @@
 #
 # Automatically generated file; DO NOT EDIT.
-# Linux/x86 5.4.69 Kernel Configuration
+# Linux/x86 5.4.70 Kernel Configuration
 #
 
 #