From b4b23f08d858c1204b2feee50ce18dde69a73e5c Mon Sep 17 00:00:00 2001 From: Matthias Maennich Date: Fri, 18 Oct 2019 16:22:30 +0100 Subject: [PATCH] ANDROID: add latest patches to quilt series up to 1caeb408f5db ("UPSTREAM: base: soc: Handle custom soc information sysfs entries") Change-Id: I070748e45a9ffbdd0fdba43fe56b99db90a10b08 Signed-off-by: Matthias Maennich --- ...NDROID-Fix-x86_64-allmodconfig-build.patch | 41 ++ ...Enable-BPF_JIT-and-BPF_JIT_ALWAYS_ON.patch | 71 ++++ ...OID-gki_defconfig-enable-CONFIG_NLS_.patch | 139 +++++++ ...PARAVIRT-and-CONFIG_HYPERVISOR_GUEST.patch | 30 ++ ...DROID-gki_defconfig-enable-REGULATOR.patch | 37 ++ ...g-enable-accelerated-AES-and-SHA-256.patch | 47 +++ ...DROID-gki_defconfig-enable-fs-verity.patch | 41 ++ ...nfig-enabled-CONFIG_TMPFS-explicitly.patch | 46 +++ ...ix-sparse-warning-in-ion-system-heap.patch | 31 ++ ...dd-an-IOCTL-to-check-ION-ABI-version.patch | 67 ++++ ...to_dev-to-look-up-device-from-fwnode.patch | 68 ++++ ...nking-devices-during-device-addition.patch | 240 ++++++++++++ ...e-Add-sync_state-driver-bus-callback.patch | 252 ++++++++++++ ...during-init-and-of_platform_populate.patch | 76 ++++ ...nal-dependency-link-from-DT-bindings.patch | 362 ++++++++++++++++++ ...-for-all-child-supplier-depencencies.patch | 90 +++++ ...rsc-modularize-RSC-controller-driver.patch | 63 +++ ...rs-make-headers-archive-reproducible.patch | 65 ++++ ...custom-soc-information-sysfs-entries.patch | 118 ++++++ ...d-pre-and-post-change-rate-callbacks.patch | 87 +++++ ..._defconfig-Enable-CONFIG_DM_SNAPSHOT.patch | 43 +++ patches/series | 23 +- 22 files changed, 2036 insertions(+), 1 deletion(-) create mode 100644 patches/ANDROID-Fix-x86_64-allmodconfig-build.patch create mode 100644 patches/ANDROID-gki_defconfig-Enable-BPF_JIT-and-BPF_JIT_ALWAYS_ON.patch create mode 100644 patches/ANDROID-gki_defconfig-enable-CONFIG_NLS_.patch create mode 100644 patches/ANDROID-gki_defconfig-enable-CONFIG_PARAVIRT-and-CONFIG_HYPERVISOR_GUEST.patch create mode 100644 patches/ANDROID-gki_defconfig-enable-REGULATOR.patch create mode 100644 patches/ANDROID-gki_defconfig-enable-accelerated-AES-and-SHA-256.patch create mode 100644 patches/ANDROID-gki_defconfig-enable-fs-verity.patch create mode 100644 patches/ANDROID-gki_defconfig-enabled-CONFIG_TMPFS-explicitly.patch create mode 100644 patches/ANDROID-staging-ion-fix-sparse-warning-in-ion-system-heap.patch create mode 100644 patches/Add-an-IOCTL-to-check-ION-ABI-version.patch create mode 100644 patches/FROMGIT-driver-core-Add-fwnode_to_dev-to-look-up-device-from-fwnode.patch create mode 100644 patches/FROMGIT-driver-core-Add-support-for-linking-devices-during-device-addition.patch create mode 100644 patches/FROMGIT-driver-core-Add-sync_state-driver-bus-callback.patch create mode 100644 patches/FROMGIT-of-platform-Pause-resume-sync-state-during-init-and-of_platform_populate.patch create mode 100644 patches/FROMGIT-of-property-Add-functional-dependency-link-from-DT-bindings.patch create mode 100644 patches/FROMGIT-of-property-Create-device-links-for-all-child-supplier-depencencies.patch create mode 100644 patches/Revert-drivers-qcom-rpmh-rsc-modularize-RSC-controller-driver.patch create mode 100644 patches/Revert-kheaders-make-headers-archive-reproducible.patch create mode 100644 patches/UPSTREAM-base-soc-Handle-custom-soc-information-sysfs-entries.patch create mode 100644 patches/clk-add-pre-and-post-change-rate-callbacks.patch create mode 100644 patches/gki_defconfig-Enable-CONFIG_DM_SNAPSHOT.patch diff --git a/patches/ANDROID-Fix-x86_64-allmodconfig-build.patch b/patches/ANDROID-Fix-x86_64-allmodconfig-build.patch new file mode 100644 index 000000000000..fb81b8ce89a7 --- /dev/null +++ b/patches/ANDROID-Fix-x86_64-allmodconfig-build.patch @@ -0,0 +1,41 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Alistair Delva +Date: Fri, 11 Oct 2019 10:24:23 -0400 +Subject: ANDROID: Fix x86_64 allmodconfig build + +CONFIG_KVM_INTEL depends on asm volatile goto which is about to be +supported in clang, but we haven't landed the upgraded compiler yet. +Suppress use of this kernel feature for now. + +In file included from arch/x86/kvm/vmx/vmx.h:11: +arch/x86/kvm/vmx/ops.h:157:2: error: 'asm goto' constructs are not +supported yet +vmx_asm2(vmwrite, "r"(field), "rm"(value), field, value); +^ + +Change-Id: If21ca65a7bd1e43c5f66a93a6108cf8aa49a9c64 +Signed-off-by: Alistair Delva +--- + build.config.allmodconfig | 4 +++- + 1 file changed, 3 insertions(+), 1 deletion(-) + +diff --git a/build.config.allmodconfig b/build.config.allmodconfig +index deaa8f3d5a69..854a8f8aa3f2 100644 +--- a/build.config.allmodconfig ++++ b/build.config.allmodconfig +@@ -2,12 +2,14 @@ DEFCONFIG=allmodconfig + KCONFIG_ALLCONFIG=${ROOT_DIR}/common/arch/${ARCH%_*}/configs/gki_defconfig + + # XFS_FS is currently broken on this branch with clang-9 ++# KVM_INTEL is broken on this branch due to lack of asm-goto support in clang + POST_DEFCONFIG_CMDS="update_config" + function update_config() { + ${KERNEL_DIR}/scripts/config --file ${OUT_DIR}/.config \ + -d TEST_KMOD \ + -d XFS_FS \ +- -d CPU_BIG_ENDIAN ++ -d CPU_BIG_ENDIAN \ ++ -d KVM_INTEL + (cd ${OUT_DIR} && \ + make O=${OUT_DIR} $archsubarch CC=${CC} CROSS_COMPILE=${CROSS_COMPILE} olddefconfig) + } diff --git a/patches/ANDROID-gki_defconfig-Enable-BPF_JIT-and-BPF_JIT_ALWAYS_ON.patch b/patches/ANDROID-gki_defconfig-Enable-BPF_JIT-and-BPF_JIT_ALWAYS_ON.patch new file mode 100644 index 000000000000..6cf2a2f474cf --- /dev/null +++ b/patches/ANDROID-gki_defconfig-Enable-BPF_JIT-and-BPF_JIT_ALWAYS_ON.patch @@ -0,0 +1,71 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Maciej=20=C5=BBenczykowski?= +Date: Tue, 8 Oct 2019 08:51:00 -0700 +Subject: ANDROID: gki_defconfig: Enable BPF_JIT and BPF_JIT_ALWAYS_ON +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Generated via: + echo 'CONFIG_BPF_JIT=y' >> arch/x86/configs/gki_defconfig + echo 'CONFIG_BPF_JIT_ALWAYS_ON=y' >> arch/x86/configs/gki_defconfig + + make ARCH=x86_64 gki_defconfig + make ARCH=x86_64 savedefconfig + mv defconfig arch/x86/configs/gki_defconfig + + echo 'CONFIG_BPF_JIT=y' >> arch/arm64/configs/gki_defconfig + echo 'CONFIG_BPF_JIT_ALWAYS_ON=y' >> arch/arm64/configs/gki_defconfig + + make ARCH=arm64 gki_defconfig + make ARCH=arm64 savedefconfig + mv defconfig arch/arm64/configs/gki_defconfig + +Bug: 140377409 +Signed-off-by: Maciej Żenczykowski +Change-Id: I84e917b75ca2cbe4d4b61c0d042f9fbcf5bdf519 +--- + arch/arm64/configs/gki_defconfig | 2 ++ + arch/x86/configs/gki_defconfig | 2 ++ + 2 files changed, 4 insertions(+) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index 97e0e47767e2..9e3b34fa8b64 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -28,6 +28,7 @@ CONFIG_BLK_DEV_INITRD=y + # CONFIG_FHANDLE is not set + CONFIG_KALLSYMS_ALL=y + CONFIG_BPF_SYSCALL=y ++CONFIG_BPF_JIT_ALWAYS_ON=y + # CONFIG_RSEQ is not set + CONFIG_EMBEDDED=y + # CONFIG_VM_EVENT_COUNTERS is not set +@@ -187,6 +188,7 @@ CONFIG_NET_EMATCH_U32=y + CONFIG_NET_CLS_ACT=y + CONFIG_VSOCKETS=y + CONFIG_VIRTIO_VSOCKETS=y ++CONFIG_BPF_JIT=y + CONFIG_BT=y + CONFIG_CFG80211=y + # CONFIG_CFG80211_DEFAULT_PS is not set +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index 7890c249bca9..f539970bf631 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -27,6 +27,7 @@ CONFIG_BLK_DEV_INITRD=y + # CONFIG_FHANDLE is not set + CONFIG_KALLSYMS_ALL=y + CONFIG_BPF_SYSCALL=y ++CONFIG_BPF_JIT_ALWAYS_ON=y + # CONFIG_RSEQ is not set + CONFIG_EMBEDDED=y + # CONFIG_VM_EVENT_COUNTERS is not set +@@ -159,6 +160,7 @@ CONFIG_NET_EMATCH_U32=y + CONFIG_NET_CLS_ACT=y + CONFIG_VSOCKETS=m + CONFIG_VIRTIO_VSOCKETS=m ++CONFIG_BPF_JIT=y + CONFIG_CAN=m + # CONFIG_CAN_BCM is not set + # CONFIG_CAN_GW is not set diff --git a/patches/ANDROID-gki_defconfig-enable-CONFIG_NLS_.patch b/patches/ANDROID-gki_defconfig-enable-CONFIG_NLS_.patch new file mode 100644 index 000000000000..9f5b623ef1bd --- /dev/null +++ b/patches/ANDROID-gki_defconfig-enable-CONFIG_NLS_.patch @@ -0,0 +1,139 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Ram Muthiah +Date: Tue, 8 Oct 2019 15:12:37 -0700 +Subject: ANDROID: gki_defconfig: enable CONFIG_NLS_* + +CONFIG_NLS_CODEPAGE_437 and CONFIG_NLS_ISO8859_1 are needed by cuttlefish +to pass the CTS test - StorageManagerTest#testMountAndUnmountObbNormal + +Adding the remaining 47 NLS Configs to account for possible i18n +requirements not caught by CTS/VTS + +Bug: 138199351 +Change-Id: I897873c8454f8329f4dc53d9af71907ba71790b7 +Signed-off-by: Ram Muthiah +--- + arch/arm64/configs/gki_defconfig | 49 ++++++++++++++++++++++++++++++++ + arch/x86/configs/gki_defconfig | 49 ++++++++++++++++++++++++++++++++ + 2 files changed, 98 insertions(+) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index 0b7669f8fedd..29cc5898a871 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -391,6 +391,55 @@ CONFIG_SDCARD_FS=y + CONFIG_PSTORE=y + CONFIG_PSTORE_CONSOLE=y + CONFIG_PSTORE_RAM=y ++CONFIG_NLS_CODEPAGE_437=y ++CONFIG_NLS_CODEPAGE_737=y ++CONFIG_NLS_CODEPAGE_775=y ++CONFIG_NLS_CODEPAGE_850=y ++CONFIG_NLS_CODEPAGE_852=y ++CONFIG_NLS_CODEPAGE_855=y ++CONFIG_NLS_CODEPAGE_857=y ++CONFIG_NLS_CODEPAGE_860=y ++CONFIG_NLS_CODEPAGE_861=y ++CONFIG_NLS_CODEPAGE_862=y ++CONFIG_NLS_CODEPAGE_863=y ++CONFIG_NLS_CODEPAGE_864=y ++CONFIG_NLS_CODEPAGE_865=y ++CONFIG_NLS_CODEPAGE_866=y ++CONFIG_NLS_CODEPAGE_869=y ++CONFIG_NLS_CODEPAGE_936=y ++CONFIG_NLS_CODEPAGE_950=y ++CONFIG_NLS_CODEPAGE_932=y ++CONFIG_NLS_CODEPAGE_949=y ++CONFIG_NLS_CODEPAGE_874=y ++CONFIG_NLS_ISO8859_8=y ++CONFIG_NLS_CODEPAGE_1250=y ++CONFIG_NLS_CODEPAGE_1251=y ++CONFIG_NLS_ASCII=y ++CONFIG_NLS_ISO8859_1=y ++CONFIG_NLS_ISO8859_2=y ++CONFIG_NLS_ISO8859_3=y ++CONFIG_NLS_ISO8859_4=y ++CONFIG_NLS_ISO8859_5=y ++CONFIG_NLS_ISO8859_6=y ++CONFIG_NLS_ISO8859_7=y ++CONFIG_NLS_ISO8859_9=y ++CONFIG_NLS_ISO8859_13=y ++CONFIG_NLS_ISO8859_14=y ++CONFIG_NLS_ISO8859_15=y ++CONFIG_NLS_KOI8_R=y ++CONFIG_NLS_KOI8_U=y ++CONFIG_NLS_MAC_ROMAN=y ++CONFIG_NLS_MAC_CELTIC=y ++CONFIG_NLS_MAC_CENTEURO=y ++CONFIG_NLS_MAC_CROATIAN=y ++CONFIG_NLS_MAC_CYRILLIC=y ++CONFIG_NLS_MAC_GAELIC=y ++CONFIG_NLS_MAC_GREEK=y ++CONFIG_NLS_MAC_ICELAND=y ++CONFIG_NLS_MAC_INUIT=y ++CONFIG_NLS_MAC_ROMANIAN=y ++CONFIG_NLS_MAC_TURKISH=y ++CONFIG_NLS_UTF8=y + CONFIG_SECURITY_PERF_EVENTS_RESTRICT=y + CONFIG_SECURITY=y + CONFIG_SECURITY_NETWORK=y +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index 78283ea8c1c8..5059dcaf01bb 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -324,6 +324,55 @@ CONFIG_SDCARD_FS=y + CONFIG_PSTORE=y + CONFIG_PSTORE_CONSOLE=y + CONFIG_PSTORE_RAM=y ++CONFIG_NLS_CODEPAGE_437=y ++CONFIG_NLS_CODEPAGE_737=y ++CONFIG_NLS_CODEPAGE_775=y ++CONFIG_NLS_CODEPAGE_850=y ++CONFIG_NLS_CODEPAGE_852=y ++CONFIG_NLS_CODEPAGE_855=y ++CONFIG_NLS_CODEPAGE_857=y ++CONFIG_NLS_CODEPAGE_860=y ++CONFIG_NLS_CODEPAGE_861=y ++CONFIG_NLS_CODEPAGE_862=y ++CONFIG_NLS_CODEPAGE_863=y ++CONFIG_NLS_CODEPAGE_864=y ++CONFIG_NLS_CODEPAGE_865=y ++CONFIG_NLS_CODEPAGE_866=y ++CONFIG_NLS_CODEPAGE_869=y ++CONFIG_NLS_CODEPAGE_936=y ++CONFIG_NLS_CODEPAGE_950=y ++CONFIG_NLS_CODEPAGE_932=y ++CONFIG_NLS_CODEPAGE_949=y ++CONFIG_NLS_CODEPAGE_874=y ++CONFIG_NLS_ISO8859_8=y ++CONFIG_NLS_CODEPAGE_1250=y ++CONFIG_NLS_CODEPAGE_1251=y ++CONFIG_NLS_ASCII=y ++CONFIG_NLS_ISO8859_1=y ++CONFIG_NLS_ISO8859_2=y ++CONFIG_NLS_ISO8859_3=y ++CONFIG_NLS_ISO8859_4=y ++CONFIG_NLS_ISO8859_5=y ++CONFIG_NLS_ISO8859_6=y ++CONFIG_NLS_ISO8859_7=y ++CONFIG_NLS_ISO8859_9=y ++CONFIG_NLS_ISO8859_13=y ++CONFIG_NLS_ISO8859_14=y ++CONFIG_NLS_ISO8859_15=y ++CONFIG_NLS_KOI8_R=y ++CONFIG_NLS_KOI8_U=y ++CONFIG_NLS_MAC_ROMAN=y ++CONFIG_NLS_MAC_CELTIC=y ++CONFIG_NLS_MAC_CENTEURO=y ++CONFIG_NLS_MAC_CROATIAN=y ++CONFIG_NLS_MAC_CYRILLIC=y ++CONFIG_NLS_MAC_GAELIC=y ++CONFIG_NLS_MAC_GREEK=y ++CONFIG_NLS_MAC_ICELAND=y ++CONFIG_NLS_MAC_INUIT=y ++CONFIG_NLS_MAC_ROMANIAN=y ++CONFIG_NLS_MAC_TURKISH=y ++CONFIG_NLS_UTF8=y + CONFIG_SECURITY_PERF_EVENTS_RESTRICT=y + CONFIG_SECURITY=y + CONFIG_SECURITY_NETWORK=y diff --git a/patches/ANDROID-gki_defconfig-enable-CONFIG_PARAVIRT-and-CONFIG_HYPERVISOR_GUEST.patch b/patches/ANDROID-gki_defconfig-enable-CONFIG_PARAVIRT-and-CONFIG_HYPERVISOR_GUEST.patch new file mode 100644 index 000000000000..7c8f54ea5c5c --- /dev/null +++ b/patches/ANDROID-gki_defconfig-enable-CONFIG_PARAVIRT-and-CONFIG_HYPERVISOR_GUEST.patch @@ -0,0 +1,30 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Ram Muthiah +Date: Thu, 10 Oct 2019 08:45:15 -0700 +Subject: ANDROID: gki_defconfig: enable CONFIG_PARAVIRT and + CONFIG_HYPERVISOR_GUEST + +CONFIG_HYPERVISOR_GUEST is needed by cuttlefish to pass the CTS Bionic tests: +clock_getres_CLOCK_MONOTONIC, clock_getres_CLOCK_REALTIME, and +clock_getres_CLOCK_BOOTTIME + +Bug: 138199351 +Change-Id: I3e209035cdd7a29e020078f8aba567d9c8446347 +Signed-off-by: Ram Muthiah +--- + arch/x86/configs/gki_defconfig | 2 ++ + 1 file changed, 2 insertions(+) + +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index 5059dcaf01bb..0e23b0cc3a8c 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -37,6 +37,8 @@ CONFIG_SLAB_FREELIST_RANDOM=y + CONFIG_SLAB_FREELIST_HARDENED=y + CONFIG_PROFILING=y + CONFIG_SMP=y ++CONFIG_HYPERVISOR_GUEST=y ++CONFIG_PARAVIRT=y + CONFIG_NR_CPUS=32 + CONFIG_EFI=y + CONFIG_PM_WAKELOCKS=y diff --git a/patches/ANDROID-gki_defconfig-enable-REGULATOR.patch b/patches/ANDROID-gki_defconfig-enable-REGULATOR.patch new file mode 100644 index 000000000000..6d9f0f2670a9 --- /dev/null +++ b/patches/ANDROID-gki_defconfig-enable-REGULATOR.patch @@ -0,0 +1,37 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Tri Vo +Date: Tue, 8 Oct 2019 12:38:34 -0700 +Subject: ANDROID: gki_defconfig: enable REGULATOR + +Fixes: 142334529 +Change-Id: If2e17aec00c2f2202f6f9203192afcd8e12228a6 +Signed-off-by: Tri Vo +--- + arch/arm64/configs/gki_defconfig | 1 + + arch/x86/configs/gki_defconfig | 1 + + 2 files changed, 2 insertions(+) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index 9e3b34fa8b64..0b7669f8fedd 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -293,6 +293,7 @@ CONFIG_DEVFREQ_THERMAL=y + CONFIG_WATCHDOG=y + CONFIG_MFD_ACT8945A=y + CONFIG_MFD_SYSCON=y ++CONFIG_REGULATOR=y + CONFIG_MEDIA_SUPPORT=y + CONFIG_MEDIA_CAMERA_SUPPORT=y + CONFIG_MEDIA_CONTROLLER=y +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index f539970bf631..78283ea8c1c8 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -252,6 +252,7 @@ CONFIG_GPIOLIB=y + # CONFIG_HWMON is not set + CONFIG_DEVFREQ_THERMAL=y + # CONFIG_X86_PKG_TEMP_THERMAL is not set ++CONFIG_REGULATOR=y + CONFIG_MEDIA_SUPPORT=y + CONFIG_MEDIA_CAMERA_SUPPORT=y + CONFIG_DRM=y diff --git a/patches/ANDROID-gki_defconfig-enable-accelerated-AES-and-SHA-256.patch b/patches/ANDROID-gki_defconfig-enable-accelerated-AES-and-SHA-256.patch new file mode 100644 index 000000000000..b628bb68957f --- /dev/null +++ b/patches/ANDROID-gki_defconfig-enable-accelerated-AES-and-SHA-256.patch @@ -0,0 +1,47 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Eric Biggers +Date: Wed, 9 Oct 2019 13:00:58 -0700 +Subject: ANDROID: gki_defconfig: enable accelerated AES and SHA-256 + +Enable AES and SHA-256 accelerated with the ARM Cryptography Extensions +or with AES-NI, as recommended by +kernel-configs/android-4.19/android-recommended-{arm64,x86}.config. +These are ~10x faster than the other software implementations of AES and +SHA-256 on most devices, and often are required to get acceptable +fscrypt and dm-verity performance. + +Bug: 142410832 +Change-Id: Ia2794f47711132d5caa9021e6e81fb625e02be8d +Signed-off-by: Eric Biggers +--- + arch/arm64/configs/gki_defconfig | 3 ++- + arch/x86/configs/gki_defconfig | 2 ++ + 2 files changed, 4 insertions(+), 1 deletion(-) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index 29cc5898a871..98520ebdd4d6 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -69,7 +69,8 @@ CONFIG_ARM_SCPI_PROTOCOL=y + # CONFIG_ARM_SCPI_POWER_DOMAIN is not set + # CONFIG_EFI_ARMSTUB_DTB_LOADER is not set + CONFIG_ARM64_CRYPTO=y +-CONFIG_CRYPTO_AES_ARM64=y ++CONFIG_CRYPTO_SHA2_ARM64_CE=y ++CONFIG_CRYPTO_AES_ARM64_CE_BLK=y + CONFIG_KPROBES=y + CONFIG_MODULES=y + CONFIG_MODULE_UNLOAD=y +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index 0e23b0cc3a8c..931fcbdced69 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -381,6 +381,8 @@ CONFIG_SECURITY_NETWORK=y + CONFIG_HARDENED_USERCOPY=y + CONFIG_SECURITY_SELINUX=y + CONFIG_CRYPTO_ADIANTUM=y ++CONFIG_CRYPTO_SHA256_SSSE3=y ++CONFIG_CRYPTO_AES_NI_INTEL=y + CONFIG_CRYPTO_LZ4=y + CONFIG_CRYPTO_ZSTD=y + CONFIG_CRYPTO_ANSI_CPRNG=y diff --git a/patches/ANDROID-gki_defconfig-enable-fs-verity.patch b/patches/ANDROID-gki_defconfig-enable-fs-verity.patch new file mode 100644 index 000000000000..d0eba23c8a79 --- /dev/null +++ b/patches/ANDROID-gki_defconfig-enable-fs-verity.patch @@ -0,0 +1,41 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Eric Biggers +Date: Thu, 10 Oct 2019 15:45:41 -0700 +Subject: ANDROID: gki_defconfig: enable fs-verity + +fs-verity will be used for APK verification in R. + +Bug: 142494008 +Change-Id: Ia18eb35fcdbccabab47de5fb26daba455fc1eb77 +Signed-off-by: Eric Biggers +--- + arch/arm64/configs/gki_defconfig | 2 ++ + arch/x86/configs/gki_defconfig | 2 ++ + 2 files changed, 4 insertions(+) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index ed21a0d79f4c..80ebf75319a1 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -381,6 +381,8 @@ CONFIG_EXT4_FS_SECURITY=y + CONFIG_F2FS_FS=y + CONFIG_F2FS_FS_SECURITY=y + CONFIG_FS_ENCRYPTION=y ++CONFIG_FS_VERITY=y ++CONFIG_FS_VERITY_BUILTIN_SIGNATURES=y + # CONFIG_DNOTIFY is not set + CONFIG_QUOTA=y + CONFIG_QFMT_V2=y +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index fbcf73e4f66f..18c3429c7ede 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -313,6 +313,8 @@ CONFIG_EXT4_FS_SECURITY=y + CONFIG_F2FS_FS=y + CONFIG_F2FS_FS_SECURITY=y + CONFIG_FS_ENCRYPTION=y ++CONFIG_FS_VERITY=y ++CONFIG_FS_VERITY_BUILTIN_SIGNATURES=y + # CONFIG_DNOTIFY is not set + CONFIG_QUOTA=y + CONFIG_QFMT_V2=y diff --git a/patches/ANDROID-gki_defconfig-enabled-CONFIG_TMPFS-explicitly.patch b/patches/ANDROID-gki_defconfig-enabled-CONFIG_TMPFS-explicitly.patch new file mode 100644 index 000000000000..950b0bb248b6 --- /dev/null +++ b/patches/ANDROID-gki_defconfig-enabled-CONFIG_TMPFS-explicitly.patch @@ -0,0 +1,46 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Yongqin Liu +Date: Thu, 10 Oct 2019 11:35:16 +0800 +Subject: ANDROID: gki_defconfig: enabled CONFIG_TMPFS explicitly + +otherwise will cause init boot failure reported like this: + +[ 1.959344] Run /init as init process +[ 1.966119] tmpfs: Unknown parameter 'mode' +[ 1.971092] tmpfs: Unknown parameter 'mode' +[ 1.975426] tmpfs: Unknown parameter 'mode' +[ 1.979709] tmpfs: Unknown parameter 'mode' +[ 1.984298] init: mount("tmpfs", "/dev", "tmpfs", MS_NOSUID, "mode=0755") failed Invalid argument +[ 1.993214] init: mount("tmpfs", "/mnt", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV, "mode=0755,uid=0,gid=1000") failed Invalid argument +[ 2.005417] init: mount("tmpfs", "/apex", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV, "mode=0755,uid=0,gid=0") failed Invalid argument +[ 2.017435] init: mount("tmpfs", "/debug_ramdisk", "tmpfs", MS_NOEXEC | MS_NOSUID | MS_NODEV, "mode=0755,uid=0,gid=0") failed Invalid argument +[ 2.030276] init: Init encountered errors starting first stage, aborting +[ 2.057074] init: #00 pc 00000000002eeac8 /init (UnwindStackCurrent::UnwindFromContext(unsigned long, void*)+96) +[ 2.067403] init: #01 pc 00000000002730c4 /init (android::init::InitFatalReboot()+92) +[ 2.075341] init: #02 pc 00000000002754f4 /init (android::init::InitAborter(char const*)+44) +[ 2.083887] init: #03 pc 00000000002ae4f8 /init (android::base::LogMessage::~LogMessage()+608) +[ 2.092605] init: #04 pc 000000000026aba8 /init (android::init::FirstStageMain(int, char**)+4400) +[ 2.101588] init: #05 pc 00000000003599e4 /init (__real_libc_init(void*, void (*)(), int (*)(int, char**, char**), structors_array_t const*, bionic_tcb*)+572) +[ 2.115863] init: Reboot ending, jumping to kernel +[ 2.121709] reboot: Restarting system with command 'bootloader' + +Tested: with hikey + +Change-Id: I607856cbcc5bfdaf304b13089c07ca0cf10c2f76 +Signed-off-by: Yongqin Liu +--- + arch/arm64/configs/gki_defconfig | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index 98520ebdd4d6..6ccf6c7ef9ec 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -387,6 +387,7 @@ CONFIG_FUSE_FS=y + CONFIG_OVERLAY_FS=y + CONFIG_MSDOS_FS=y + CONFIG_VFAT_FS=y ++CONFIG_TMPFS=y + # CONFIG_EFIVAR_FS is not set + CONFIG_SDCARD_FS=y + CONFIG_PSTORE=y diff --git a/patches/ANDROID-staging-ion-fix-sparse-warning-in-ion-system-heap.patch b/patches/ANDROID-staging-ion-fix-sparse-warning-in-ion-system-heap.patch new file mode 100644 index 000000000000..6cfa27b7a926 --- /dev/null +++ b/patches/ANDROID-staging-ion-fix-sparse-warning-in-ion-system-heap.patch @@ -0,0 +1,31 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Sandeep Patil +Date: Wed, 9 Oct 2019 21:38:04 -0700 +Subject: ANDROID: staging: ion: fix sparse warning in ion system heap + +drivers/staging/android/ion/heaps/ion_system_heap.c:250:24: sparse: sparse: +symbol 'system_heap' was not declared. Should it be static? + +Fixes: 142434553 +Test: Build and boot cuttlefish + +Change-Id: I6e1eb9365ca12c2d081533ed2db9881086531ec7 +Reported-by: kbuild test robot +Signed-off-by: Sandeep Patil +--- + drivers/staging/android/ion/heaps/ion_system_heap.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/drivers/staging/android/ion/heaps/ion_system_heap.c b/drivers/staging/android/ion/heaps/ion_system_heap.c +index 792cd130e493..054324784ab9 100644 +--- a/drivers/staging/android/ion/heaps/ion_system_heap.c ++++ b/drivers/staging/android/ion/heaps/ion_system_heap.c +@@ -244,7 +244,7 @@ static struct ion_heap_ops system_heap_ops = { + .shrink = ion_system_heap_shrink, + }; + +-struct ion_system_heap system_heap = { ++static struct ion_system_heap system_heap = { + .heap = { + .ops = &system_heap_ops, + .type = ION_HEAP_TYPE_SYSTEM, diff --git a/patches/Add-an-IOCTL-to-check-ION-ABI-version.patch b/patches/Add-an-IOCTL-to-check-ION-ABI-version.patch new file mode 100644 index 000000000000..365d1c77286c --- /dev/null +++ b/patches/Add-an-IOCTL-to-check-ION-ABI-version.patch @@ -0,0 +1,67 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Hridya Valsaraju +Date: Wed, 2 Oct 2019 14:32:19 -0700 +Subject: Add an IOCTL to check ION ABI version + +Userspace needs a way to detect ION ABI version at runtime to determine +heap IDs. CURRENT_ION_ABI_VERSION is set to 2 considering legacy and +upstream versions as 0 and 1. + +Bug: 140916230 +Test: make + +Signed-off-by: Hridya Valsaraju + +Change-Id: Ie9d9e23c2d8323620832906d33745d599cbce6be +--- + drivers/staging/android/ion/ion.c | 6 ++++++ + include/uapi/linux/ion.h | 7 +++++++ + 2 files changed, 13 insertions(+) + +diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c +index 2c915579f60b..a499a76453ee 100644 +--- a/drivers/staging/android/ion/ion.c ++++ b/drivers/staging/android/ion/ion.c +@@ -27,6 +27,8 @@ + + #include "ion_private.h" + ++#define ION_CURRENT_ABI_VERSION 2 ++ + static struct ion_device *internal_dev; + + /* Entry into ION allocator for rest of the kernel */ +@@ -108,6 +110,7 @@ static int ion_query_heaps(struct ion_heap_query *query) + union ion_ioctl_arg { + struct ion_allocation_data allocation; + struct ion_heap_query query; ++ u32 ion_abi_version; + }; + + static int validate_ioctl_arg(unsigned int cmd, union ion_ioctl_arg *arg) +@@ -169,6 +172,9 @@ static long ion_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) + case ION_IOC_HEAP_QUERY: + ret = ion_query_heaps(&data.query); + break; ++ case ION_IOC_ABI_VERSION: ++ data.ion_abi_version = ION_CURRENT_ABI_VERSION; ++ break; + default: + return -ENOTTY; + } +diff --git a/include/uapi/linux/ion.h b/include/uapi/linux/ion.h +index ad773e5fa4d2..fdb2eba7f500 100644 +--- a/include/uapi/linux/ion.h ++++ b/include/uapi/linux/ion.h +@@ -159,4 +159,11 @@ struct ion_heap_query { + #define ION_IOC_HEAP_QUERY _IOWR(ION_IOC_MAGIC, 8, \ + struct ion_heap_query) + ++/** ++ * DOC: ION_IOC_HEAP_ABI_VERSION - return ABI version ++ * ++ * Returns ABI version for this driver ++ */ ++#define ION_IOC_ABI_VERSION _IOR(ION_IOC_MAGIC, 9, \ ++ __u32) + #endif /* _UAPI_LINUX_ION_H */ diff --git a/patches/FROMGIT-driver-core-Add-fwnode_to_dev-to-look-up-device-from-fwnode.patch b/patches/FROMGIT-driver-core-Add-fwnode_to_dev-to-look-up-device-from-fwnode.patch new file mode 100644 index 000000000000..217740268a81 --- /dev/null +++ b/patches/FROMGIT-driver-core-Add-fwnode_to_dev-to-look-up-device-from-fwnode.patch @@ -0,0 +1,68 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Saravana Kannan +Date: Wed, 4 Sep 2019 14:11:20 -0700 +Subject: FROMGIT: driver core: Add fwnode_to_dev() to look up device from + fwnode + +It's often useful to look up a device that corresponds to a fwnode. So +add an API to do that irrespective of the bus on which the device has +been added to. + +Signed-off-by: Saravana Kannan +Link: https://lore.kernel.org/r/20190904211126.47518-2-saravanak@google.com +Signed-off-by: Greg Kroah-Hartman + +(cherry-picked from commit 372a67c0c5ef63f55bd1eb480d9555328d8ec0f2 + https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git driver-core-next) + +Bug: 141703324 +Change-Id: I68c36177da083bfb04e73c1b754e740f40faf284 +--- + drivers/base/core.c | 7 +++++++ + include/linux/fwnode.h | 2 ++ + 2 files changed, 9 insertions(+) + +diff --git a/drivers/base/core.c b/drivers/base/core.c +index 2db62d98e395..510fabf8918c 100644 +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -2198,6 +2198,10 @@ int device_add(struct device *dev) + BUS_NOTIFY_ADD_DEVICE, dev); + + kobject_uevent(&dev->kobj, KOBJ_ADD); ++ ++ if (dev->fwnode && !dev->fwnode->dev) ++ dev->fwnode->dev = dev; ++ + bus_probe_device(dev); + if (parent) + klist_add_tail(&dev->p->knode_parent, +@@ -2342,6 +2346,9 @@ void device_del(struct device *dev) + kill_device(dev); + device_unlock(dev); + ++ if (dev->fwnode && dev->fwnode->dev == dev) ++ dev->fwnode->dev = NULL; ++ + /* Notify clients of device removal. This call must come + * before dpm_sysfs_remove(). + */ +diff --git a/include/linux/fwnode.h b/include/linux/fwnode.h +index ababd6bc82f3..d8c6d231d577 100644 +--- a/include/linux/fwnode.h ++++ b/include/linux/fwnode.h +@@ -17,6 +17,7 @@ struct device; + struct fwnode_handle { + struct fwnode_handle *secondary; + const struct fwnode_operations *ops; ++ struct device *dev; + }; + + /** +@@ -123,5 +124,6 @@ struct fwnode_operations { + if (fwnode_has_op(fwnode, op)) \ + (fwnode)->ops->op(fwnode, ## __VA_ARGS__); \ + } while (false) ++#define get_dev_from_fwnode(fwnode) get_device((fwnode)->dev) + + #endif diff --git a/patches/FROMGIT-driver-core-Add-support-for-linking-devices-during-device-addition.patch b/patches/FROMGIT-driver-core-Add-support-for-linking-devices-during-device-addition.patch new file mode 100644 index 000000000000..05de50e179dc --- /dev/null +++ b/patches/FROMGIT-driver-core-Add-support-for-linking-devices-during-device-addition.patch @@ -0,0 +1,240 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Saravana Kannan +Date: Wed, 4 Sep 2019 14:11:21 -0700 +Subject: FROMGIT: driver core: Add support for linking devices during device + addition + +The firmware corresponding to a device (dev.fwnode) might be able to +provide functional dependency information between a device and its +supplier and consumer devices. Tracking this functional dependency +allows optimizing device probe order and informing a supplier when all +its consumers have probed (and thereby actively managing their +resources). + +The existing device links feature allows tracking and using +supplier-consumer relationships. So, this patch adds the add_links() +fwnode callback to allow firmware to create device links for each +device as the device is added. + +However, when consumer devices are added, they might not have a supplier +device to link to despite needing mandatory resources/functionality from +one or more suppliers. A waiting_for_suppliers list is created to track +such consumers and retry linking them when new devices get added. + +Signed-off-by: Saravana Kannan +Link: https://lore.kernel.org/r/20190904211126.47518-3-saravanak@google.com +Signed-off-by: Greg Kroah-Hartman + +(cherry-picked from commit e2ae9bcc4aaacda04edb75c4eea93384719efaa5 + https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git driver-core-next) + +Bug: 141703324 +Change-Id: I97ffa57fa71588bf198e78d8b5a313b860b17bf5 +--- + Documentation/driver-api/device_link.rst | 3 +- + drivers/base/core.c | 88 ++++++++++++++++++++++++ + include/linux/device.h | 2 + + include/linux/fwnode.h | 17 +++++ + 4 files changed, 109 insertions(+), 1 deletion(-) + +diff --git a/Documentation/driver-api/device_link.rst b/Documentation/driver-api/device_link.rst +index 1b5020ec6517..bc2d89af88ce 100644 +--- a/Documentation/driver-api/device_link.rst ++++ b/Documentation/driver-api/device_link.rst +@@ -281,7 +281,8 @@ State machine + :c:func:`driver_bound()`.) + + * Before a consumer device is probed, presence of supplier drivers is +- verified by checking that links to suppliers are in ``DL_STATE_AVAILABLE`` ++ verified by checking the consumer device is not in the wait_for_suppliers ++ list and by checking that links to suppliers are in ``DL_STATE_AVAILABLE`` + state. The state of the links is updated to ``DL_STATE_CONSUMER_PROBE``. + (Call to :c:func:`device_links_check_suppliers()` from + :c:func:`really_probe()`.) +diff --git a/drivers/base/core.c b/drivers/base/core.c +index 510fabf8918c..b3896da73b3d 100644 +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -44,6 +44,8 @@ early_param("sysfs.deprecated", sysfs_deprecated_setup); + #endif + + /* Device links support. */ ++static LIST_HEAD(wait_for_suppliers); ++static DEFINE_MUTEX(wfs_lock); + + #ifdef CONFIG_SRCU + static DEFINE_MUTEX(device_links_lock); +@@ -430,6 +432,58 @@ struct device_link *device_link_add(struct device *consumer, + } + EXPORT_SYMBOL_GPL(device_link_add); + ++/** ++ * device_link_wait_for_supplier - Add device to wait_for_suppliers list ++ * @consumer: Consumer device ++ * ++ * Marks the @consumer device as waiting for suppliers to become available by ++ * adding it to the wait_for_suppliers list. The consumer device will never be ++ * probed until it's removed from the wait_for_suppliers list. ++ * ++ * The caller is responsible for adding the links to the supplier devices once ++ * they are available and removing the @consumer device from the ++ * wait_for_suppliers list once links to all the suppliers have been created. ++ * ++ * This function is NOT meant to be called from the probe function of the ++ * consumer but rather from code that creates/adds the consumer device. ++ */ ++static void device_link_wait_for_supplier(struct device *consumer) ++{ ++ mutex_lock(&wfs_lock); ++ list_add_tail(&consumer->links.needs_suppliers, &wait_for_suppliers); ++ mutex_unlock(&wfs_lock); ++} ++ ++/** ++ * device_link_add_missing_supplier_links - Add links from consumer devices to ++ * supplier devices, leaving any ++ * consumer with inactive suppliers on ++ * the wait_for_suppliers list ++ * ++ * Loops through all consumers waiting on suppliers and tries to add all their ++ * supplier links. If that succeeds, the consumer device is removed from ++ * wait_for_suppliers list. Otherwise, they are left in the wait_for_suppliers ++ * list. Devices left on the wait_for_suppliers list will not be probed. ++ * ++ * The fwnode add_links callback is expected to return 0 if it has found and ++ * added all the supplier links for the consumer device. It should return an ++ * error if it isn't able to do so. ++ * ++ * The caller of device_link_wait_for_supplier() is expected to call this once ++ * it's aware of potential suppliers becoming available. ++ */ ++static void device_link_add_missing_supplier_links(void) ++{ ++ struct device *dev, *tmp; ++ ++ mutex_lock(&wfs_lock); ++ list_for_each_entry_safe(dev, tmp, &wait_for_suppliers, ++ links.needs_suppliers) ++ if (!fwnode_call_int_op(dev->fwnode, add_links, dev)) ++ list_del_init(&dev->links.needs_suppliers); ++ mutex_unlock(&wfs_lock); ++} ++ + static void device_link_free(struct device_link *link) + { + while (refcount_dec_not_one(&link->rpm_active)) +@@ -564,6 +618,17 @@ int device_links_check_suppliers(struct device *dev) + struct device_link *link; + int ret = 0; + ++ /* ++ * Device waiting for supplier to become available is not allowed to ++ * probe. ++ */ ++ mutex_lock(&wfs_lock); ++ if (!list_empty(&dev->links.needs_suppliers)) { ++ mutex_unlock(&wfs_lock); ++ return -EPROBE_DEFER; ++ } ++ mutex_unlock(&wfs_lock); ++ + device_links_write_lock(); + + list_for_each_entry(link, &dev->links.suppliers, c_node) { +@@ -848,6 +913,10 @@ static void device_links_purge(struct device *dev) + { + struct device_link *link, *ln; + ++ mutex_lock(&wfs_lock); ++ list_del(&dev->links.needs_suppliers); ++ mutex_unlock(&wfs_lock); ++ + /* + * Delete all of the remaining links from this device to any other + * devices (either consumers or suppliers). +@@ -1712,6 +1781,7 @@ void device_initialize(struct device *dev) + #endif + INIT_LIST_HEAD(&dev->links.consumers); + INIT_LIST_HEAD(&dev->links.suppliers); ++ INIT_LIST_HEAD(&dev->links.needs_suppliers); + dev->links.status = DL_DEV_NO_DRIVER; + } + EXPORT_SYMBOL_GPL(device_initialize); +@@ -2202,6 +2272,24 @@ int device_add(struct device *dev) + if (dev->fwnode && !dev->fwnode->dev) + dev->fwnode->dev = dev; + ++ /* ++ * Check if any of the other devices (consumers) have been waiting for ++ * this device (supplier) to be added so that they can create a device ++ * link to it. ++ * ++ * This needs to happen after device_pm_add() because device_link_add() ++ * requires the supplier be registered before it's called. ++ * ++ * But this also needs to happe before bus_probe_device() to make sure ++ * waiting consumers can link to it before the driver is bound to the ++ * device and the driver sync_state callback is called for this device. ++ */ ++ device_link_add_missing_supplier_links(); ++ ++ if (fwnode_has_op(dev->fwnode, add_links) ++ && fwnode_call_int_op(dev->fwnode, add_links, dev)) ++ device_link_wait_for_supplier(dev); ++ + bus_probe_device(dev); + if (parent) + klist_add_tail(&dev->p->knode_parent, +diff --git a/include/linux/device.h b/include/linux/device.h +index 297239a08bb7..c6fb5b3431b7 100644 +--- a/include/linux/device.h ++++ b/include/linux/device.h +@@ -1135,11 +1135,13 @@ enum dl_dev_state { + * struct dev_links_info - Device data related to device links. + * @suppliers: List of links to supplier devices. + * @consumers: List of links to consumer devices. ++ * @needs_suppliers: Hook to global list of devices waiting for suppliers. + * @status: Driver status information. + */ + struct dev_links_info { + struct list_head suppliers; + struct list_head consumers; ++ struct list_head needs_suppliers; + enum dl_dev_state status; + }; + +diff --git a/include/linux/fwnode.h b/include/linux/fwnode.h +index d8c6d231d577..6ae05b9ce359 100644 +--- a/include/linux/fwnode.h ++++ b/include/linux/fwnode.h +@@ -66,6 +66,21 @@ struct fwnode_reference_args { + * endpoint node. + * @graph_get_port_parent: Return the parent node of a port node. + * @graph_parse_endpoint: Parse endpoint for port and endpoint id. ++ * @add_links: Called after the device corresponding to the fwnode is added ++ * using device_add(). The function is expected to create device ++ * links to all the suppliers of the device that are available at ++ * the time this function is called. The function must NOT stop ++ * at the first failed device link if other unlinked supplier ++ * devices are present in the system. If some suppliers are not ++ * yet available, this function will be called again when other ++ * devices are added to allow creating device links to any newly ++ * available suppliers. ++ * ++ * Return 0 if device links have been successfully created to all ++ * the suppliers of this device or if the supplier information is ++ * not known. Return an error if and only if the supplier ++ * information is known but some of the suppliers are not yet ++ * available to create device links to. + */ + struct fwnode_operations { + struct fwnode_handle *(*get)(struct fwnode_handle *fwnode); +@@ -103,6 +118,8 @@ struct fwnode_operations { + (*graph_get_port_parent)(struct fwnode_handle *fwnode); + int (*graph_parse_endpoint)(const struct fwnode_handle *fwnode, + struct fwnode_endpoint *endpoint); ++ int (*add_links)(const struct fwnode_handle *fwnode, ++ struct device *dev); + }; + + #define fwnode_has_op(fwnode, op) \ diff --git a/patches/FROMGIT-driver-core-Add-sync_state-driver-bus-callback.patch b/patches/FROMGIT-driver-core-Add-sync_state-driver-bus-callback.patch new file mode 100644 index 000000000000..5e5297a56011 --- /dev/null +++ b/patches/FROMGIT-driver-core-Add-sync_state-driver-bus-callback.patch @@ -0,0 +1,252 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Saravana Kannan +Date: Wed, 4 Sep 2019 14:11:23 -0700 +Subject: FROMGIT: driver core: Add sync_state driver/bus callback + +This sync_state driver/bus callback is called once all the consumers +of a supplier have probed successfully. + +This allows the supplier device's driver/bus to sync the supplier +device's state to the software state with the guarantee that all the +consumers are actively managing the resources provided by the supplier +device. + +To maintain backwards compatibility and ease transition from existing +frameworks and resource cleanup schemes, late_initcall_sync is the +earliest when the sync_state callback might be called. + +There is no upper bound on the time by which the sync_state callback +has to be called. This is because if a consumer device never probes, +the supplier has to maintain its resources in the state left by the +bootloader. For example, if the bootloader leaves the display +backlight at a fixed voltage and the backlight driver is never probed, +you don't want the backlight to ever be turned off after boot up. + +Also, when multiple devices are added after kernel init, some +suppliers could be added before their consumer devices get added. In +these instances, the supplier devices could get their sync_state +callback called right after they probe because the consumers devices +haven't had a chance to create device links to the suppliers. + +To handle this correctly, this change also provides APIs to +pause/resume sync state callbacks so that when multiple devices are +added, their sync_state callback evaluation can be postponed to happen +after all of them are added. + +kbuild test robot reported missing documentation for device.state_synced +Reported-by: kbuild test robot +Signed-off-by: Saravana Kannan +Link: https://lore.kernel.org/r/20190904211126.47518-5-saravanak@google.com +Signed-off-by: Greg Kroah-Hartman + +(cherry-picked from commit fc5a251d0fd7ca9038bab78a8c97932c8c6ca23b + https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git driver-core-next) + +Bug: 141703324 +Change-Id: I3e0a483c76d6ae3e5fe5aa6b3df65d0417c65ebb +--- + drivers/base/core.c | 72 ++++++++++++++++++++++++++++++++++++++++++ + include/linux/device.h | 24 ++++++++++++++ + 2 files changed, 96 insertions(+) + +diff --git a/drivers/base/core.c b/drivers/base/core.c +index b3896da73b3d..acbf0b1414ab 100644 +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -46,6 +46,8 @@ early_param("sysfs.deprecated", sysfs_deprecated_setup); + /* Device links support. */ + static LIST_HEAD(wait_for_suppliers); + static DEFINE_MUTEX(wfs_lock); ++static LIST_HEAD(deferred_sync); ++static unsigned int defer_sync_state_count = 1; + + #ifdef CONFIG_SRCU + static DEFINE_MUTEX(device_links_lock); +@@ -648,6 +650,69 @@ int device_links_check_suppliers(struct device *dev) + return ret; + } + ++static void __device_links_supplier_sync_state(struct device *dev) ++{ ++ struct device_link *link; ++ ++ if (dev->state_synced) ++ return; ++ ++ list_for_each_entry(link, &dev->links.consumers, s_node) { ++ if (!(link->flags & DL_FLAG_MANAGED)) ++ continue; ++ if (link->status != DL_STATE_ACTIVE) ++ return; ++ } ++ ++ if (dev->bus->sync_state) ++ dev->bus->sync_state(dev); ++ else if (dev->driver && dev->driver->sync_state) ++ dev->driver->sync_state(dev); ++ ++ dev->state_synced = true; ++} ++ ++void device_links_supplier_sync_state_pause(void) ++{ ++ device_links_write_lock(); ++ defer_sync_state_count++; ++ device_links_write_unlock(); ++} ++ ++void device_links_supplier_sync_state_resume(void) ++{ ++ struct device *dev, *tmp; ++ ++ device_links_write_lock(); ++ if (!defer_sync_state_count) { ++ WARN(true, "Unmatched sync_state pause/resume!"); ++ goto out; ++ } ++ defer_sync_state_count--; ++ if (defer_sync_state_count) ++ goto out; ++ ++ list_for_each_entry_safe(dev, tmp, &deferred_sync, links.defer_sync) { ++ __device_links_supplier_sync_state(dev); ++ list_del_init(&dev->links.defer_sync); ++ } ++out: ++ device_links_write_unlock(); ++} ++ ++static int sync_state_resume_initcall(void) ++{ ++ device_links_supplier_sync_state_resume(); ++ return 0; ++} ++late_initcall(sync_state_resume_initcall); ++ ++static void __device_links_supplier_defer_sync(struct device *sup) ++{ ++ if (list_empty(&sup->links.defer_sync)) ++ list_add_tail(&sup->links.defer_sync, &deferred_sync); ++} ++ + /** + * device_links_driver_bound - Update device links after probing its driver. + * @dev: Device to update the links for. +@@ -692,6 +757,11 @@ void device_links_driver_bound(struct device *dev) + + WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); + WRITE_ONCE(link->status, DL_STATE_ACTIVE); ++ ++ if (defer_sync_state_count) ++ __device_links_supplier_defer_sync(link->supplier); ++ else ++ __device_links_supplier_sync_state(link->supplier); + } + + dev->links.status = DL_DEV_DRIVER_BOUND; +@@ -808,6 +878,7 @@ void device_links_driver_cleanup(struct device *dev) + WRITE_ONCE(link->status, DL_STATE_DORMANT); + } + ++ list_del_init(&dev->links.defer_sync); + __device_links_no_driver(dev); + + device_links_write_unlock(); +@@ -1782,6 +1853,7 @@ void device_initialize(struct device *dev) + INIT_LIST_HEAD(&dev->links.consumers); + INIT_LIST_HEAD(&dev->links.suppliers); + INIT_LIST_HEAD(&dev->links.needs_suppliers); ++ INIT_LIST_HEAD(&dev->links.defer_sync); + dev->links.status = DL_DEV_NO_DRIVER; + } + EXPORT_SYMBOL_GPL(device_initialize); +diff --git a/include/linux/device.h b/include/linux/device.h +index c6fb5b3431b7..6978bb471567 100644 +--- a/include/linux/device.h ++++ b/include/linux/device.h +@@ -80,6 +80,13 @@ extern void bus_remove_file(struct bus_type *, struct bus_attribute *); + * that generate uevents to add the environment variables. + * @probe: Called when a new device or driver add to this bus, and callback + * the specific driver's probe to initial the matched device. ++ * @sync_state: Called to sync device state to software state after all the ++ * state tracking consumers linked to this device (present at ++ * the time of late_initcall) have successfully bound to a ++ * driver. If the device has no consumers, this function will ++ * be called at late_initcall_sync level. If the device has ++ * consumers that are never bound to a driver, this function ++ * will never get called until they do. + * @remove: Called when a device removed from this bus. + * @shutdown: Called at shut-down time to quiesce the device. + * +@@ -123,6 +130,7 @@ struct bus_type { + int (*match)(struct device *dev, struct device_driver *drv); + int (*uevent)(struct device *dev, struct kobj_uevent_env *env); + int (*probe)(struct device *dev); ++ void (*sync_state)(struct device *dev); + int (*remove)(struct device *dev); + void (*shutdown)(struct device *dev); + +@@ -340,6 +348,13 @@ enum probe_type { + * @probe: Called to query the existence of a specific device, + * whether this driver can work with it, and bind the driver + * to a specific device. ++ * @sync_state: Called to sync device state to software state after all the ++ * state tracking consumers linked to this device (present at ++ * the time of late_initcall) have successfully bound to a ++ * driver. If the device has no consumers, this function will ++ * be called at late_initcall_sync level. If the device has ++ * consumers that are never bound to a driver, this function ++ * will never get called until they do. + * @remove: Called when the device is removed from the system to + * unbind a device from this driver. + * @shutdown: Called at shut-down time to quiesce the device. +@@ -379,6 +394,7 @@ struct device_driver { + const struct acpi_device_id *acpi_match_table; + + int (*probe) (struct device *dev); ++ void (*sync_state)(struct device *dev); + int (*remove) (struct device *dev); + void (*shutdown) (struct device *dev); + int (*suspend) (struct device *dev, pm_message_t state); +@@ -1136,12 +1152,14 @@ enum dl_dev_state { + * @suppliers: List of links to supplier devices. + * @consumers: List of links to consumer devices. + * @needs_suppliers: Hook to global list of devices waiting for suppliers. ++ * @defer_sync: Hook to global list of devices that have deferred sync_state. + * @status: Driver status information. + */ + struct dev_links_info { + struct list_head suppliers; + struct list_head consumers; + struct list_head needs_suppliers; ++ struct list_head defer_sync; + enum dl_dev_state status; + }; + +@@ -1217,6 +1235,9 @@ struct dev_links_info { + * @offline: Set after successful invocation of bus type's .offline(). + * @of_node_reused: Set if the device-tree node is shared with an ancestor + * device. ++ * @state_synced: The hardware state of this device has been synced to match ++ * the software state of this device by calling the driver/bus ++ * sync_state() callback. + * @dma_coherent: this particular device is dma coherent, even if the + * architecture supports non-coherent devices. + * +@@ -1313,6 +1334,7 @@ struct device { + bool offline_disabled:1; + bool offline:1; + bool of_node_reused:1; ++ bool state_synced:1; + #if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \ + defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \ + defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL) +@@ -1655,6 +1677,8 @@ struct device_link *device_link_add(struct device *consumer, + struct device *supplier, u32 flags); + void device_link_del(struct device_link *link); + void device_link_remove(void *consumer, struct device *supplier); ++void device_links_supplier_sync_state_pause(void); ++void device_links_supplier_sync_state_resume(void); + + #ifndef dev_fmt + #define dev_fmt(fmt) fmt diff --git a/patches/FROMGIT-of-platform-Pause-resume-sync-state-during-init-and-of_platform_populate.patch b/patches/FROMGIT-of-platform-Pause-resume-sync-state-during-init-and-of_platform_populate.patch new file mode 100644 index 000000000000..cabfdfe2b84b --- /dev/null +++ b/patches/FROMGIT-of-platform-Pause-resume-sync-state-during-init-and-of_platform_populate.patch @@ -0,0 +1,76 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Saravana Kannan +Date: Wed, 4 Sep 2019 14:11:24 -0700 +Subject: FROMGIT: of/platform: Pause/resume sync state during init and + of_platform_populate() + +When all the top level devices are populated from DT during kernel +init, the supplier devices could be added and probed before the +consumer devices are added and linked to the suppliers. To avoid the +sync_state() callback from being called prematurely, pause the +sync_state() callbacks before populating the devices and resume them +at late_initcall_sync(). + +Similarly, when children devices are populated from a module using +of_platform_populate(), there could be supplier-consumer dependencies +between the children devices that are populated. To avoid the same +problem with sync_state() being called prematurely, pause and resume +sync_state() callbacks across of_platform_populate(). + +Signed-off-by: Saravana Kannan +Link: https://lore.kernel.org/r/20190904211126.47518-6-saravanak@google.com +Signed-off-by: Greg Kroah-Hartman + +(cherry-picked from commit 5e6669387e2287f25f09fd0abd279dae104cfa7e + https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git driver-core-next) + +Bug: 141703324 +Change-Id: Ia43ebbc9071d4d6a59b347ccae99fcf0ab192269 +--- + drivers/of/platform.c | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/drivers/of/platform.c b/drivers/of/platform.c +index b47a2292fe8e..d93891a05f60 100644 +--- a/drivers/of/platform.c ++++ b/drivers/of/platform.c +@@ -480,6 +480,7 @@ int of_platform_populate(struct device_node *root, + pr_debug("%s()\n", __func__); + pr_debug(" starting at: %pOF\n", root); + ++ device_links_supplier_sync_state_pause(); + for_each_child_of_node(root, child) { + rc = of_platform_bus_create(child, matches, lookup, parent, true); + if (rc) { +@@ -487,6 +488,8 @@ int of_platform_populate(struct device_node *root, + break; + } + } ++ device_links_supplier_sync_state_resume(); ++ + of_node_set_flag(root, OF_POPULATED_BUS); + + of_node_put(root); +@@ -518,6 +521,7 @@ static int __init of_platform_default_populate_init(void) + if (!of_have_populated_dt()) + return -ENODEV; + ++ device_links_supplier_sync_state_pause(); + /* + * Handle certain compatibles explicitly, since we don't want to create + * platform_devices for every node in /reserved-memory with a +@@ -538,6 +542,14 @@ static int __init of_platform_default_populate_init(void) + return 0; + } + arch_initcall_sync(of_platform_default_populate_init); ++ ++static int __init of_platform_sync_state_init(void) ++{ ++ if (of_have_populated_dt()) ++ device_links_supplier_sync_state_resume(); ++ return 0; ++} ++late_initcall_sync(of_platform_sync_state_init); + #endif + + int of_platform_device_destroy(struct device *dev, void *data) diff --git a/patches/FROMGIT-of-property-Add-functional-dependency-link-from-DT-bindings.patch b/patches/FROMGIT-of-property-Add-functional-dependency-link-from-DT-bindings.patch new file mode 100644 index 000000000000..036ccfde126b --- /dev/null +++ b/patches/FROMGIT-of-property-Add-functional-dependency-link-from-DT-bindings.patch @@ -0,0 +1,362 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Saravana Kannan +Date: Wed, 4 Sep 2019 14:11:22 -0700 +Subject: FROMGIT: of: property: Add functional dependency link from DT + bindings + +Add device links after the devices are created (but before they are +probed) by looking at common DT bindings like clocks and +interconnects. + +Automatically adding device links for functional dependencies at the +framework level provides the following benefits: + +- Optimizes device probe order and avoids the useless work of + attempting probes of devices that will not probe successfully + (because their suppliers aren't present or haven't probed yet). + + For example, in a commonly available mobile SoC, registering just + one consumer device's driver at an initcall level earlier than the + supplier device's driver causes 11 failed probe attempts before the + consumer device probes successfully. This was with a kernel with all + the drivers statically compiled in. This problem gets a lot worse if + all the drivers are loaded as modules without direct symbol + dependencies. + +- Supplier devices like clock providers, interconnect providers, etc + need to keep the resources they provide active and at a particular + state(s) during boot up even if their current set of consumers don't + request the resource to be active. This is because the rest of the + consumers might not have probed yet and turning off the resource + before all the consumers have probed could lead to a hang or + undesired user experience. + + Some frameworks (Eg: regulator) handle this today by turning off + "unused" resources at late_initcall_sync and hoping all the devices + have probed by then. This is not a valid assumption for systems with + loadable modules. Other frameworks (Eg: clock) just don't handle + this due to the lack of a clear signal for when they can turn off + resources. This leads to downstream hacks to handle cases like this + that can easily be solved in the upstream kernel. + + By linking devices before they are probed, we give suppliers a clear + count of the number of dependent consumers. Once all of the + consumers are active, the suppliers can turn off the unused + resources without making assumptions about the number of consumers. + +By default we just add device-links to track "driver presence" (probe +succeeded) of the supplier device. If any other functionality provided +by device-links are needed, it is left to the consumer/supplier +devices to change the link when they probe. + +kbuild test robot reported clang error about missing const +Reported-by: kbuild test robot +Signed-off-by: Saravana Kannan +Link: https://lore.kernel.org/r/20190904211126.47518-4-saravanak@google.com +Signed-off-by: Greg Kroah-Hartman + +(cherry-picked from commit a3e1d1a7f5fcccaf1d252278425fea9a4a553100 + https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git driver-core-next) + +Bug: 141703324 +Change-Id: I54a2dc3c4e91e418bcf1895c16bb8658dcfe1bee +--- + .../admin-guide/kernel-parameters.rst | 1 + + .../admin-guide/kernel-parameters.txt | 6 + + drivers/of/property.c | 241 ++++++++++++++++++ + 3 files changed, 248 insertions(+) + +diff --git a/Documentation/admin-guide/kernel-parameters.rst b/Documentation/admin-guide/kernel-parameters.rst +index d05d531b4ec9..6d421694d98e 100644 +--- a/Documentation/admin-guide/kernel-parameters.rst ++++ b/Documentation/admin-guide/kernel-parameters.rst +@@ -127,6 +127,7 @@ parameter is applicable:: + NET Appropriate network support is enabled. + NUMA NUMA support is enabled. + NFS Appropriate NFS support is enabled. ++ OF Devicetree is enabled. + OSS OSS sound support is enabled. + PV_OPS A paravirtualized kernel is enabled. + PARIDE The ParIDE (parallel port IDE) subsystem is enabled. +diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt +index a84a83f8881e..dc727fa8c831 100644 +--- a/Documentation/admin-guide/kernel-parameters.txt ++++ b/Documentation/admin-guide/kernel-parameters.txt +@@ -3194,6 +3194,12 @@ + This can be set from sysctl after boot. + See Documentation/admin-guide/sysctl/vm.rst for details. + ++ of_devlink [OF, KNL] Create device links between consumer and ++ supplier devices by scanning the devictree to infer the ++ consumer/supplier relationships. A consumer device ++ will not be probed until all the supplier devices have ++ probed successfully. ++ + ohci1394_dma=early [HW] enable debugging via the ohci1394 driver. + See Documentation/debugging-via-ohci1394.txt for more + info. +diff --git a/drivers/of/property.c b/drivers/of/property.c +index d7fa75e31f22..23b5ee5b0570 100644 +--- a/drivers/of/property.c ++++ b/drivers/of/property.c +@@ -25,6 +25,7 @@ + #include + #include + #include ++#include + + #include "of_private.h" + +@@ -985,6 +986,245 @@ of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode, + return of_device_get_match_data(dev); + } + ++static bool of_is_ancestor_of(struct device_node *test_ancestor, ++ struct device_node *child) ++{ ++ of_node_get(child); ++ while (child) { ++ if (child == test_ancestor) { ++ of_node_put(child); ++ return false; ++ } ++ child = of_get_next_parent(child); ++ } ++ return true; ++} ++ ++/** ++ * of_link_to_phandle - Add device link to supplier from supplier phandle ++ * @dev: consumer device ++ * @sup_np: phandle to supplier device tree node ++ * ++ * Given a phandle to a supplier device tree node (@sup_np), this function ++ * finds the device that owns the supplier device tree node and creates a ++ * device link from @dev consumer device to the supplier device. This function ++ * doesn't create device links for invalid scenarios such as trying to create a ++ * link with a parent device as the consumer of its child device. In such ++ * cases, it returns an error. ++ * ++ * Returns: ++ * - 0 if link successfully created to supplier ++ * - -EAGAIN if linking to the supplier should be reattempted ++ * - -EINVAL if the supplier link is invalid and should not be created ++ * - -ENODEV if there is no device that corresponds to the supplier phandle ++ */ ++static int of_link_to_phandle(struct device *dev, struct device_node *sup_np) ++{ ++ struct device *sup_dev; ++ u32 dl_flags = DL_FLAG_AUTOPROBE_CONSUMER; ++ int ret = 0; ++ struct device_node *tmp_np = sup_np; ++ ++ of_node_get(sup_np); ++ /* ++ * Find the device node that contains the supplier phandle. It may be ++ * @sup_np or it may be an ancestor of @sup_np. ++ */ ++ while (sup_np && !of_find_property(sup_np, "compatible", NULL)) ++ sup_np = of_get_next_parent(sup_np); ++ if (!sup_np) { ++ dev_dbg(dev, "Not linking to %pOFP - No device\n", tmp_np); ++ return -ENODEV; ++ } ++ ++ /* ++ * Don't allow linking a device node as a consumer of one of its ++ * descendant nodes. By definition, a child node can't be a functional ++ * dependency for the parent node. ++ */ ++ if (!of_is_ancestor_of(dev->of_node, sup_np)) { ++ dev_dbg(dev, "Not linking to %pOFP - is descendant\n", sup_np); ++ of_node_put(sup_np); ++ return -EINVAL; ++ } ++ sup_dev = get_dev_from_fwnode(&sup_np->fwnode); ++ of_node_put(sup_np); ++ if (!sup_dev) ++ return -EAGAIN; ++ if (!device_link_add(dev, sup_dev, dl_flags)) ++ ret = -EAGAIN; ++ put_device(sup_dev); ++ return ret; ++} ++ ++/** ++ * parse_prop_cells - Property parsing function for suppliers ++ * ++ * @np: Pointer to device tree node containing a list ++ * @prop_name: Name of property to be parsed. Expected to hold phandle values ++ * @index: For properties holding a list of phandles, this is the index ++ * into the list. ++ * @list_name: Property name that is known to contain list of phandle(s) to ++ * supplier(s) ++ * @cells_name: property name that specifies phandles' arguments count ++ * ++ * This is a helper function to parse properties that have a known fixed name ++ * and are a list of phandles and phandle arguments. ++ * ++ * Returns: ++ * - phandle node pointer with refcount incremented. Caller must of_node_put() ++ * on it when done. ++ * - NULL if no phandle found at index ++ */ ++static struct device_node *parse_prop_cells(struct device_node *np, ++ const char *prop_name, int index, ++ const char *list_name, ++ const char *cells_name) ++{ ++ struct of_phandle_args sup_args; ++ ++ if (strcmp(prop_name, list_name)) ++ return NULL; ++ ++ if (of_parse_phandle_with_args(np, list_name, cells_name, index, ++ &sup_args)) ++ return NULL; ++ ++ return sup_args.np; ++} ++ ++static struct device_node *parse_clocks(struct device_node *np, ++ const char *prop_name, int index) ++{ ++ return parse_prop_cells(np, prop_name, index, "clocks", "#clock-cells"); ++} ++ ++static struct device_node *parse_interconnects(struct device_node *np, ++ const char *prop_name, int index) ++{ ++ return parse_prop_cells(np, prop_name, index, "interconnects", ++ "#interconnect-cells"); ++} ++ ++static int strcmp_suffix(const char *str, const char *suffix) ++{ ++ unsigned int len, suffix_len; ++ ++ len = strlen(str); ++ suffix_len = strlen(suffix); ++ if (len <= suffix_len) ++ return -1; ++ return strcmp(str + len - suffix_len, suffix); ++} ++ ++static struct device_node *parse_regulators(struct device_node *np, ++ const char *prop_name, int index) ++{ ++ if (index || strcmp_suffix(prop_name, "-supply")) ++ return NULL; ++ ++ return of_parse_phandle(np, prop_name, 0); ++} ++ ++/** ++ * struct supplier_bindings - Property parsing functions for suppliers ++ * ++ * @parse_prop: function name ++ * parse_prop() finds the node corresponding to a supplier phandle ++ * @parse_prop.np: Pointer to device node holding supplier phandle property ++ * @parse_prop.prop_name: Name of property holding a phandle value ++ * @parse_prop.index: For properties holding a list of phandles, this is the ++ * index into the list ++ * ++ * Returns: ++ * parse_prop() return values are ++ * - phandle node pointer with refcount incremented. Caller must of_node_put() ++ * on it when done. ++ * - NULL if no phandle found at index ++ */ ++struct supplier_bindings { ++ struct device_node *(*parse_prop)(struct device_node *np, ++ const char *prop_name, int index); ++}; ++ ++static const struct supplier_bindings bindings[] = { ++ { .parse_prop = parse_clocks, }, ++ { .parse_prop = parse_interconnects, }, ++ { .parse_prop = parse_regulators, }, ++ {}, ++}; ++ ++/** ++ * of_link_property - Create device links to suppliers listed in a property ++ * @dev: Consumer device ++ * @con_np: The consumer device tree node which contains the property ++ * @prop_name: Name of property to be parsed ++ * ++ * This function checks if the property @prop_name that is present in the ++ * @con_np device tree node is one of the known common device tree bindings ++ * that list phandles to suppliers. If @prop_name isn't one, this function ++ * doesn't do anything. ++ * ++ * If @prop_name is one, this function attempts to create device links from the ++ * consumer device @dev to all the devices of the suppliers listed in ++ * @prop_name. ++ * ++ * Any failed attempt to create a device link will NOT result in an immediate ++ * return. of_link_property() must create links to all the available supplier ++ * devices even when attempts to create a link to one or more suppliers fail. ++ */ ++static int of_link_property(struct device *dev, struct device_node *con_np, ++ const char *prop_name) ++{ ++ struct device_node *phandle; ++ const struct supplier_bindings *s = bindings; ++ unsigned int i = 0; ++ bool matched = false; ++ int ret = 0; ++ ++ /* Do not stop at first failed link, link all available suppliers. */ ++ while (!matched && s->parse_prop) { ++ while ((phandle = s->parse_prop(con_np, prop_name, i))) { ++ matched = true; ++ i++; ++ if (of_link_to_phandle(dev, phandle) == -EAGAIN) ++ ret = -EAGAIN; ++ of_node_put(phandle); ++ } ++ s++; ++ } ++ return ret; ++} ++ ++static int __of_link_to_suppliers(struct device *dev, ++ struct device_node *con_np) ++{ ++ struct device_node *child; ++ struct property *p; ++ int ret = 0; ++ ++ for_each_property_of_node(con_np, p) ++ if (of_link_property(dev, con_np, p->name)) ++ ret = -EAGAIN; ++ ++ return ret; ++} ++ ++static bool of_devlink; ++core_param(of_devlink, of_devlink, bool, 0); ++ ++static int of_fwnode_add_links(const struct fwnode_handle *fwnode, ++ struct device *dev) ++{ ++ if (!of_devlink) ++ return 0; ++ ++ if (unlikely(!is_of_node(fwnode))) ++ return 0; ++ ++ return __of_link_to_suppliers(dev, to_of_node(fwnode)); ++} ++ + const struct fwnode_operations of_fwnode_ops = { + .get = of_fwnode_get, + .put = of_fwnode_put, +@@ -1001,5 +1241,6 @@ const struct fwnode_operations of_fwnode_ops = { + .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint, + .graph_get_port_parent = of_fwnode_graph_get_port_parent, + .graph_parse_endpoint = of_fwnode_graph_parse_endpoint, ++ .add_links = of_fwnode_add_links, + }; + EXPORT_SYMBOL_GPL(of_fwnode_ops); diff --git a/patches/FROMGIT-of-property-Create-device-links-for-all-child-supplier-depencencies.patch b/patches/FROMGIT-of-property-Create-device-links-for-all-child-supplier-depencencies.patch new file mode 100644 index 000000000000..ba97c8f0d2c9 --- /dev/null +++ b/patches/FROMGIT-of-property-Create-device-links-for-all-child-supplier-depencencies.patch @@ -0,0 +1,90 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Saravana Kannan +Date: Wed, 4 Sep 2019 14:11:25 -0700 +Subject: FROMGIT: of: property: Create device links for all child-supplier + depencencies + +A parent device can have child devices that it adds when it probes. But +this probing of the parent device can happen way after kernel init is done +-- for example, when the parent device's driver is loaded as a module. + +In such cases, if the child devices depend on a supplier in the system, we +need to make sure the supplier gets the sync_state() callback only after +these child devices are added and probed. + +To achieve this, when creating device links for a device by looking at its +DT node, don't just look at DT references at the top node level. Look at DT +references in all the descendant nodes too and create device links from the +ancestor device to all these supplier devices. + +This way, when the parent device probes and adds child devices, the child +devices can then create their own device links to the suppliers and further +delay the supplier's sync_state() callback to after the child devices are +probed. + +Example: +In this illustration, -> denotes DT references and indentation +represents child status. + +Device node A + Device node B -> D + Device node C -> B, D + +Device node D + +Assume all these devices have their drivers loaded as modules. + +Without this patch, this is the sequence of events: +1. D is added. +2. A is added. +3. Device D probes. +4. Device D gets its sync_state() callback. +5. Device B and C might malfunction because their resources got + altered/turned off before they can make active requests for them. + +With this patch, this is the sequence of events: +1. D is added. +2. A is added and creates device links to D. +3. Device link from A to B is not added because A is a parent of B. +4. Device D probes. +5. Device D does not get it's sync_state() callback because consumer A + hasn't probed yet. +5. Device A probes. +5. a. Devices B and C are added. +5. b. Device links from B and C to D are added. +5. c. Device A's probe completes. +6. Device D does not get it's sync_state() callback because consumer A + has probed but consumers B and C haven't probed yet. +7. Device B and C probe. +8. Device D gets it's sync_state() callback because all its consumers + have probed. +9. None of the devices malfunction. + +Signed-off-by: Saravana Kannan +Link: https://lore.kernel.org/r/20190904211126.47518-7-saravanak@google.com +Signed-off-by: Greg Kroah-Hartman + +(cherry-picked from commit d4387cd117414ba80230f27a514be5ca4a09cfcc + https://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core.git driver-core-next) + +Fixes: 141703324 +Change-Id: I38186d6cc4671bd8747dae8c440b09717a487088 +--- + drivers/of/property.c | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/drivers/of/property.c b/drivers/of/property.c +index 23b5ee5b0570..923d6f88a99c 100644 +--- a/drivers/of/property.c ++++ b/drivers/of/property.c +@@ -1207,6 +1207,10 @@ static int __of_link_to_suppliers(struct device *dev, + if (of_link_property(dev, con_np, p->name)) + ret = -EAGAIN; + ++ for_each_child_of_node(con_np, child) ++ if (__of_link_to_suppliers(dev, child)) ++ ret = -EAGAIN; ++ + return ret; + } + diff --git a/patches/Revert-drivers-qcom-rpmh-rsc-modularize-RSC-controller-driver.patch b/patches/Revert-drivers-qcom-rpmh-rsc-modularize-RSC-controller-driver.patch new file mode 100644 index 000000000000..be67158e6678 --- /dev/null +++ b/patches/Revert-drivers-qcom-rpmh-rsc-modularize-RSC-controller-driver.patch @@ -0,0 +1,63 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Quentin Perret +Date: Thu, 26 Sep 2019 12:30:35 +0100 +Subject: Revert "drivers: qcom: rpmh-rsc: modularize RSC controller driver" + +This reverts commit 7cbdcba442ed26b789f5b3ab18b97e3aa2686bf0. +It breaks allmodconfig: + + drivers/soc/qcom/rpmhpd.o: In function `rpmhpd_aggregate_corner': + rpmhpd.c:(.text+0x8f8): undefined reference to `rpmh_write' + rpmhpd.c:(.text+0x900): undefined reference to `rpmh_write_async' + rpmhpd.c:(.text+0x9c4): undefined reference to `rpmh_write_async' + rpmhpd.c:(.text+0xa3c): undefined reference to `rpmh_write_async' + +It is not obvious that QCOM_RPMH should be tristate in the first place +when QCOM_RPMHPD needs it compiled in. + +Bug: 140224784 +Signed-off-by: Quentin Perret +Change-Id: I154b2d2b369c3654c41595bad91abd5a47d15206 +--- + drivers/soc/qcom/Kconfig | 2 +- + drivers/soc/qcom/rpmh-rsc.c | 9 +++++---- + 2 files changed, 6 insertions(+), 5 deletions(-) + +diff --git a/drivers/soc/qcom/Kconfig b/drivers/soc/qcom/Kconfig +index 119a38bf373e..661e47acc354 100644 +--- a/drivers/soc/qcom/Kconfig ++++ b/drivers/soc/qcom/Kconfig +@@ -102,7 +102,7 @@ config QCOM_RMTFS_MEM + Say y here if you intend to boot the modem remoteproc. + + config QCOM_RPMH +- tristate "Qualcomm Technologies, Inc. RPM-Hardened (RPMH) Communication driver" ++ bool "Qualcomm RPM-Hardened (RPMH) Communication" + depends on ARCH_QCOM && ARM64 || COMPILE_TEST + help + Support for communication with the hardened-RPM blocks in +diff --git a/drivers/soc/qcom/rpmh-rsc.c b/drivers/soc/qcom/rpmh-rsc.c +index d7d9e1b8a4f1..e278fc11fe5c 100644 +--- a/drivers/soc/qcom/rpmh-rsc.c ++++ b/drivers/soc/qcom/rpmh-rsc.c +@@ -11,7 +11,6 @@ + #include + #include + #include +-#include + #include + #include + #include +@@ -688,7 +687,9 @@ static struct platform_driver rpmh_driver = { + .of_match_table = rpmh_drv_match, + }, + }; +-builtin_platform_driver(rpmh_driver); + +-MODULE_LICENSE("GPL v2"); +-MODULE_DESCRIPTION("Qualcomm Technologies, Inc. RPMH communication driver"); ++static int __init rpmh_driver_init(void) ++{ ++ return platform_driver_register(&rpmh_driver); ++} ++arch_initcall(rpmh_driver_init); diff --git a/patches/Revert-kheaders-make-headers-archive-reproducible.patch b/patches/Revert-kheaders-make-headers-archive-reproducible.patch new file mode 100644 index 000000000000..a01616bd235d --- /dev/null +++ b/patches/Revert-kheaders-make-headers-archive-reproducible.patch @@ -0,0 +1,65 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Alistair Delva +Date: Wed, 9 Oct 2019 15:25:35 -0400 +Subject: Revert "kheaders: make headers archive reproducible" + +This reverts commit 86cdd2fdc4e39c388d39c7ba2396d1a9dfd66226. + +Reason: Broke "make allmodconfig" on Android build machines + +$ tar: unrecognized option '--sort=name' +Try 'tar --help' or 'tar --usage' for more information. + +Signed-off-by: Alistair Delva +Change-Id: I3d406988f23201e5ab824ca7aed215ccc9d43279 +--- + Documentation/kbuild/reproducible-builds.rst | 13 ++++--------- + kernel/gen_kheaders.sh | 5 +---- + 2 files changed, 5 insertions(+), 13 deletions(-) + +diff --git a/Documentation/kbuild/reproducible-builds.rst b/Documentation/kbuild/reproducible-builds.rst +index 503393854e2e..ab92e98c89c8 100644 +--- a/Documentation/kbuild/reproducible-builds.rst ++++ b/Documentation/kbuild/reproducible-builds.rst +@@ -16,21 +16,16 @@ the kernel may be unreproducible, and how to avoid them. + Timestamps + ---------- + +-The kernel embeds timestamps in three places: ++The kernel embeds a timestamp in two places: + + * The version string exposed by ``uname()`` and included in + ``/proc/version`` + + * File timestamps in the embedded initramfs + +-* If enabled via ``CONFIG_IKHEADERS``, file timestamps of kernel +- headers embedded in the kernel or respective module, +- exposed via ``/sys/kernel/kheaders.tar.xz`` +- +-By default the timestamp is the current time and in the case of +-``kheaders`` the various files' modification times. This must +-be overridden using the `KBUILD_BUILD_TIMESTAMP`_ variable. +-If you are building from a git commit, you could use its commit date. ++By default the timestamp is the current time. This must be overridden ++using the `KBUILD_BUILD_TIMESTAMP`_ variable. If you are building ++from a git commit, you could use its commit date. + + The kernel does *not* use the ``__DATE__`` and ``__TIME__`` macros, + and enables warnings if they are used. If you incorporate external +diff --git a/kernel/gen_kheaders.sh b/kernel/gen_kheaders.sh +index aff79e461fc9..9ff449888d9c 100755 +--- a/kernel/gen_kheaders.sh ++++ b/kernel/gen_kheaders.sh +@@ -71,10 +71,7 @@ done | cpio --quiet -pd $cpio_dir >/dev/null 2>&1 + find $cpio_dir -type f -print0 | + xargs -0 -P8 -n1 perl -pi -e 'BEGIN {undef $/;}; s/\/\*((?!SPDX).)*?\*\///smg;' + +-# Create archive and try to normalize metadata for reproducibility +-tar "${KBUILD_BUILD_TIMESTAMP:+--mtime=$KBUILD_BUILD_TIMESTAMP}" \ +- --owner=0 --group=0 --sort=name --numeric-owner \ +- -Jcf $tarfile -C $cpio_dir/ . > /dev/null ++tar -Jcf $tarfile -C $cpio_dir/ . > /dev/null + + echo "$src_files_md5" > kernel/kheaders.md5 + echo "$obj_files_md5" >> kernel/kheaders.md5 diff --git a/patches/UPSTREAM-base-soc-Handle-custom-soc-information-sysfs-entries.patch b/patches/UPSTREAM-base-soc-Handle-custom-soc-information-sysfs-entries.patch new file mode 100644 index 000000000000..7e81da9a0c9c --- /dev/null +++ b/patches/UPSTREAM-base-soc-Handle-custom-soc-information-sysfs-entries.patch @@ -0,0 +1,118 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Murali Nalajala +Date: Mon, 7 Oct 2019 13:37:42 -0700 +Subject: UPSTREAM: base: soc: Handle custom soc information sysfs entries + +Soc framework exposed sysfs entries are not sufficient for some +of the h/w platforms. Currently there is no interface where soc +drivers can expose further information about their SoCs via soc +framework. This change address this limitation where clients can +pass their custom entries as attribute group and soc framework +would expose them as sysfs properties. + +Bug: 141190076 +Signed-off-by: Murali Nalajala +Reviewed-by: Bjorn Andersson +Reviewed-by: Stephen Boyd +Link: https://lore.kernel.org/r/1570480662-25252-1-git-send-email-mnalajal@codeaurora.org +Signed-off-by: Greg Kroah-Hartman +(cherry-picked from c31e73121f4c1ec45a3e523ac6ce3ce6dafdcec1) +Signed-off-by: Greg Kroah-Hartman +Change-Id: Ia1c8d697e29052b4503da7c4b30c2c97d3b697f7 +--- + drivers/base/soc.c | 30 +++++++++++++++++------------- + include/linux/sys_soc.h | 1 + + 2 files changed, 18 insertions(+), 13 deletions(-) + +diff --git a/drivers/base/soc.c b/drivers/base/soc.c +index 7c0c5ca5953d..4af11a423475 100644 +--- a/drivers/base/soc.c ++++ b/drivers/base/soc.c +@@ -104,15 +104,12 @@ static const struct attribute_group soc_attr_group = { + .is_visible = soc_attribute_mode, + }; + +-static const struct attribute_group *soc_attr_groups[] = { +- &soc_attr_group, +- NULL, +-}; +- + static void soc_release(struct device *dev) + { + struct soc_device *soc_dev = container_of(dev, struct soc_device, dev); + ++ ida_simple_remove(&soc_ida, soc_dev->soc_dev_num); ++ kfree(soc_dev->dev.groups); + kfree(soc_dev); + } + +@@ -121,6 +118,7 @@ static struct soc_device_attribute *early_soc_dev_attr; + struct soc_device *soc_device_register(struct soc_device_attribute *soc_dev_attr) + { + struct soc_device *soc_dev; ++ const struct attribute_group **soc_attr_groups; + int ret; + + if (!soc_bus_type.p) { +@@ -136,10 +134,18 @@ struct soc_device *soc_device_register(struct soc_device_attribute *soc_dev_attr + goto out1; + } + ++ soc_attr_groups = kcalloc(3, sizeof(*soc_attr_groups), GFP_KERNEL); ++ if (!soc_attr_groups) { ++ ret = -ENOMEM; ++ goto out2; ++ } ++ soc_attr_groups[0] = &soc_attr_group; ++ soc_attr_groups[1] = soc_dev_attr->custom_attr_group; ++ + /* Fetch a unique (reclaimable) SOC ID. */ + ret = ida_simple_get(&soc_ida, 0, 0, GFP_KERNEL); + if (ret < 0) +- goto out2; ++ goto out3; + soc_dev->soc_dev_num = ret; + + soc_dev->attr = soc_dev_attr; +@@ -150,15 +156,15 @@ struct soc_device *soc_device_register(struct soc_device_attribute *soc_dev_attr + dev_set_name(&soc_dev->dev, "soc%d", soc_dev->soc_dev_num); + + ret = device_register(&soc_dev->dev); +- if (ret) +- goto out3; ++ if (ret) { ++ put_device(&soc_dev->dev); ++ return ERR_PTR(ret); ++ } + + return soc_dev; + + out3: +- ida_simple_remove(&soc_ida, soc_dev->soc_dev_num); +- put_device(&soc_dev->dev); +- soc_dev = NULL; ++ kfree(soc_attr_groups); + out2: + kfree(soc_dev); + out1: +@@ -169,8 +175,6 @@ EXPORT_SYMBOL_GPL(soc_device_register); + /* Ensure soc_dev->attr is freed prior to calling soc_device_unregister. */ + void soc_device_unregister(struct soc_device *soc_dev) + { +- ida_simple_remove(&soc_ida, soc_dev->soc_dev_num); +- + device_unregister(&soc_dev->dev); + early_soc_dev_attr = NULL; + } +diff --git a/include/linux/sys_soc.h b/include/linux/sys_soc.h +index 48ceea867dd6..d9b3cf0f410c 100644 +--- a/include/linux/sys_soc.h ++++ b/include/linux/sys_soc.h +@@ -15,6 +15,7 @@ struct soc_device_attribute { + const char *serial_number; + const char *soc_id; + const void *data; ++ const struct attribute_group *custom_attr_group; + }; + + /** diff --git a/patches/clk-add-pre-and-post-change-rate-callbacks.patch b/patches/clk-add-pre-and-post-change-rate-callbacks.patch new file mode 100644 index 000000000000..9ae7da67c9cd --- /dev/null +++ b/patches/clk-add-pre-and-post-change-rate-callbacks.patch @@ -0,0 +1,87 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: David Dai +Date: Mon, 19 Aug 2019 16:35:44 -0700 +Subject: clk: add pre and post change rate callbacks + +There are scenarios where a rate change could result in a configuration +change for both the targeted clock and its parent. + +For example, setting the rate for a clock could require both slewing its parent +PLL as well as adjusting the clock's divider values. Due to the fact that +rate change propagation always occurs from parent to child, we could exceed +the allowed operating frequencies for the clock as the parent slews to a higher +frequency before increasing the downstream divider. + +Add a pre change call back which allows the clock to adjust its divider +appropriately before any rate change has occurred from its parents to ensure +that the clock's requirements are always within safe frequencies during parent +rate changes. The symmetrical post change call back handles the scenario where +the divider adjusts to a lower value and can only be safely adjusted after the +parent rate changes. + +Change-Id: I4f8cf9df6fc256d065599de86a34cf99eae4d853 +Signed-off-by: David Dai +--- + drivers/clk/clk.c | 10 ++++++++++ + include/linux/clk-provider.h | 13 +++++++++++++ + 2 files changed, 23 insertions(+) + +diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c +index 1c677d7f7f53..020fdb8105cc 100644 +--- a/drivers/clk/clk.c ++++ b/drivers/clk/clk.c +@@ -1980,6 +1980,13 @@ static struct clk_core *clk_propagate_rate_change(struct clk_core *core, + fail_clk = core; + } + ++ if (core->ops->pre_rate_change) { ++ ret = core->ops->pre_rate_change(core->hw, core->rate, ++ core->new_rate); ++ if (ret) ++ fail_clk = core; ++ } ++ + hlist_for_each_entry(child, &core->children, child_node) { + /* Skip children who will be reparented to another clock */ + if (child->new_parent && child->new_parent != core) +@@ -2082,6 +2089,9 @@ static void clk_change_rate(struct clk_core *core) + if (core->flags & CLK_RECALC_NEW_RATES) + (void)clk_calc_new_rates(core, core->new_rate); + ++ if (core->ops->post_rate_change) ++ core->ops->post_rate_change(core->hw, old_rate, core->rate); ++ + /* + * Use safe iteration, as change_rate can actually swap parents + * for certain clock types. +diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h +index 2fdfe8061363..73e4369e8408 100644 +--- a/include/linux/clk-provider.h ++++ b/include/linux/clk-provider.h +@@ -199,6 +199,13 @@ struct clk_duty { + * directory is provided as an argument. Called with + * prepare_lock held. Returns 0 on success, -EERROR otherwise. + * ++ * @pre_rate_change: Optional callback for a clock to fulfill its rate ++ * change requirements before any rate change has occurred in ++ * its clock tree. Returns 0 on success, -EERROR otherwise. ++ * ++ * @post_rate_change: Optional callback for a clock to clean up any ++ * requirements that were needed while the clock and its tree ++ * was changing states. Returns 0 on success, -EERROR otherwise. + * + * The clk_enable/clk_disable and clk_prepare/clk_unprepare pairs allow + * implementations to split any work between atomic (enable) and sleepable +@@ -245,6 +252,12 @@ struct clk_ops { + struct clk_duty *duty); + void (*init)(struct clk_hw *hw); + void (*debug_init)(struct clk_hw *hw, struct dentry *dentry); ++ int (*pre_rate_change)(struct clk_hw *hw, ++ unsigned long rate, ++ unsigned long new_rate); ++ int (*post_rate_change)(struct clk_hw *hw, ++ unsigned long old_rate, ++ unsigned long rate); + }; + + /** diff --git a/patches/gki_defconfig-Enable-CONFIG_DM_SNAPSHOT.patch b/patches/gki_defconfig-Enable-CONFIG_DM_SNAPSHOT.patch new file mode 100644 index 000000000000..aa4a83ba0848 --- /dev/null +++ b/patches/gki_defconfig-Enable-CONFIG_DM_SNAPSHOT.patch @@ -0,0 +1,43 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Alessio Balsini +Date: Fri, 11 Oct 2019 13:50:20 +0100 +Subject: gki_defconfig: Enable CONFIG_DM_SNAPSHOT + +The snapshot dm target is required to implement the Virtual-AB +mechanism. +Introduce CONFIG_DM_SNAPSHOT in arm64 and x86 gki defconfigs to +enable this feature. + +Bug: 142527064 +Test: kernel build +Signed-off-by: Alessio Balsini +Change-Id: I69bc614509eaff259a2aa9195e7e1d406b36bbb2 +--- + arch/arm64/configs/gki_defconfig | 1 + + arch/x86/configs/gki_defconfig | 1 + + 2 files changed, 2 insertions(+) + +diff --git a/arch/arm64/configs/gki_defconfig b/arch/arm64/configs/gki_defconfig +index 6ccf6c7ef9ec..ed21a0d79f4c 100644 +--- a/arch/arm64/configs/gki_defconfig ++++ b/arch/arm64/configs/gki_defconfig +@@ -216,6 +216,7 @@ CONFIG_SCSI_UFSHCD_PLATFORM=y + CONFIG_MD=y + CONFIG_BLK_DEV_DM=y + CONFIG_DM_CRYPT=y ++CONFIG_DM_SNAPSHOT=y + CONFIG_DM_UEVENT=y + CONFIG_DM_VERITY=y + CONFIG_DM_VERITY_AVB=y +diff --git a/arch/x86/configs/gki_defconfig b/arch/x86/configs/gki_defconfig +index 931fcbdced69..fbcf73e4f66f 100644 +--- a/arch/x86/configs/gki_defconfig ++++ b/arch/x86/configs/gki_defconfig +@@ -189,6 +189,7 @@ CONFIG_BLK_DEV_SD=y + CONFIG_MD=y + CONFIG_BLK_DEV_DM=y + CONFIG_DM_CRYPT=y ++CONFIG_DM_SNAPSHOT=y + CONFIG_DM_UEVENT=y + CONFIG_DM_VERITY=y + CONFIG_DM_VERITY_AVB=y diff --git a/patches/series b/patches/series index b4abb8ec7b15..943c392c150c 100644 --- a/patches/series +++ b/patches/series @@ -2,7 +2,7 @@ # android-mainline patches # # Applies onto mainline 4f5cafb5cb84 Linux v5.4-rc3 -# Matches android-mainline c8e152bc7d05 ANDROID: staging: ion: Fix missing entry in kerneldoc header +# Matches android-mainline 1caeb408f5db UPSTREAM: base: soc: Handle custom soc information sysfs entries # ANDROID-x86-Remove-a-useless-warning-message.patch ANDROID-Kbuild-LLVMLinux-allow-overriding-clang-target-triple.patch @@ -211,3 +211,24 @@ ANDROID-sched-core-Add-a-latency-sensitive-flag-to-uclamp.patch ANDROID-sched-Introduce-uclamp-latency-and-boost-wrapper.patch ANDROID-sched-fair-Bias-EAS-placement-for-latency.patch ANDROID-Initial-abi_gki_aarch64-definition.patch +Add-an-IOCTL-to-check-ION-ABI-version.patch +FROMGIT-driver-core-Add-fwnode_to_dev-to-look-up-device-from-fwnode.patch +FROMGIT-driver-core-Add-support-for-linking-devices-during-device-addition.patch +FROMGIT-of-property-Add-functional-dependency-link-from-DT-bindings.patch +FROMGIT-driver-core-Add-sync_state-driver-bus-callback.patch +FROMGIT-of-platform-Pause-resume-sync-state-during-init-and-of_platform_populate.patch +FROMGIT-of-property-Create-device-links-for-all-child-supplier-depencencies.patch +ANDROID-gki_defconfig-Enable-BPF_JIT-and-BPF_JIT_ALWAYS_ON.patch +ANDROID-gki_defconfig-enable-REGULATOR.patch +ANDROID-gki_defconfig-enable-CONFIG_NLS_.patch +Revert-kheaders-make-headers-archive-reproducible.patch +ANDROID-staging-ion-fix-sparse-warning-in-ion-system-heap.patch +ANDROID-gki_defconfig-enable-CONFIG_PARAVIRT-and-CONFIG_HYPERVISOR_GUEST.patch +ANDROID-gki_defconfig-enable-accelerated-AES-and-SHA-256.patch +ANDROID-gki_defconfig-enabled-CONFIG_TMPFS-explicitly.patch +gki_defconfig-Enable-CONFIG_DM_SNAPSHOT.patch +ANDROID-Fix-x86_64-allmodconfig-build.patch +Revert-drivers-qcom-rpmh-rsc-modularize-RSC-controller-driver.patch +clk-add-pre-and-post-change-rate-callbacks.patch +ANDROID-gki_defconfig-enable-fs-verity.patch +UPSTREAM-base-soc-Handle-custom-soc-information-sysfs-entries.patch