diff --git a/autoghgvm.bzl b/autoghgvm.bzl new file mode 100644 index 000000000000..1f5e0de97645 --- /dev/null +++ b/autoghgvm.bzl @@ -0,0 +1,63 @@ +load(":target_variants.bzl", "lxc_variants") +load(":msm_kernel_lagvm.bzl", "define_msm_lagvm") +load(":image_opts.bzl", "boot_image_opts") + +target_name = "autoghgvm" + +def define_autoghgvm(): + _autoghgvm_in_tree_modules = [ + # keep sorted + "arch/arm64/gunyah/gh_arm_drv.ko", + "drivers/block/virtio_blk.ko", + "drivers/clk/qcom/clk-dummy.ko", + "drivers/clk/qcom/clk-qcom.ko", + "drivers/dma-buf/heaps/qcom_dma_heaps.ko", + "drivers/firmware/qcom-scm.ko", + "drivers/i2c/busses/i2c-msm-geni.ko", + "drivers/iommu/arm/arm-smmu/arm_smmu.ko", + "drivers/iommu/iommu-logger.ko", + "drivers/iommu/qcom_iommu_debug.ko", + "drivers/iommu/qcom_iommu_util.ko", + "drivers/net/net_failover.ko", + "drivers/net/virtio_net.ko", + "drivers/pinctrl/qcom/pinctrl-lemans.ko", + "drivers/pinctrl/qcom/pinctrl-msm.ko", + "drivers/soc/qcom/mem_buf/mem_buf.ko", + "drivers/soc/qcom/mem_buf/mem_buf_dev.ko", + "drivers/soc/qcom/qcom_wdt_core.ko", + "drivers/soc/qcom/rename_devices.ko", + "drivers/spi/spi-msm-geni.ko", + "drivers/spi/spidev.ko", + "drivers/tty/hvc/hvc_gunyah.ko", + "drivers/tty/serial/msm_geni_serial.ko", + "drivers/virt/gunyah/gh_ctrl.ko", + "drivers/virt/gunyah/gh_dbl.ko", + "drivers/virt/gunyah/gh_msgq.ko", + "drivers/virt/gunyah/gh_rm_drv.ko", + "drivers/virt/gunyah/gh_virt_wdt.ko", + "drivers/virtio/virtio_input.ko", + "drivers/virtio/virtio_mmio.ko", + "kernel/trace/qcom_ipc_logging.ko", + "net/core/failover.ko", + ] + + for variant in lxc_variants: + mod_list = _autoghgvm_in_tree_modules + + define_msm_lagvm( + msm_target = target_name, + variant = variant, + in_tree_module_list = mod_list, + boot_image_opts = boot_image_opts( + boot_partition_size = 0x4000000, + boot_image_header_version = 2, + base_address = 0x80000000, + page_size = 4096, + kernel_vendor_cmdline_extras = [ + # do not sort + "console=hvc0", + "androidboot.first_stage_console=1", + "bootconfig", + ], + ), + ) diff --git a/build.config.msm.autoghgvm b/build.config.msm.autoghgvm new file mode 100644 index 000000000000..b657d5ffb720 --- /dev/null +++ b/build.config.msm.autoghgvm @@ -0,0 +1,60 @@ +################################################################################ +## Inheriting configs from ACK +. "${ROOT_DIR}"/msm-kernel/build.config.common +. "${ROOT_DIR}"/msm-kernel/build.config.aarch64 + +################################################################################ +## Variant setup +MSM_ARCH=autoghgvm +VARIANTS=(defconfig debug_defconfig debug-defconfig perf_defconfig perf-defconfig) +[ -z "${VARIANT}" ] && VARIANT=debug_defconfig + +if [ -e "${ROOT_DIR}/msm-kernel" ] && [ "${KERNEL_DIR}" = "common" ]; then + KERNEL_DIR="msm-kernel" +fi + +BOOT_IMAGE_HEADER_VERSION=2 +BASE_ADDRESS=0x80000000 +PAGE_SIZE=4096 +BUILD_VENDOR_DLKM=1 +SUPER_IMAGE_SIZE=0x10000000 +TRIM_UNUSED_MODULES=1 +BUILD_INIT_BOOT_IMG=1 + +[ -z "${DT_OVERLAY_SUPPORT}" ] && DT_OVERLAY_SUPPORT=1 + +if [ "${KERNEL_CMDLINE_CONSOLE_AUTO}" != "0" ]; then + KERNEL_VENDOR_CMDLINE+=' console=hvc0 androidboot.first_stage_console=1 ' +fi + +KERNEL_VENDOR_CMDLINE+=' bootconfig ' + +################################################################################ +## Inheriting MSM configs +. ${KERNEL_DIR}/build.config.msm.common + +# Common MSM configuration for using GKI defconfig as a fragment +DEFCONFIG="gki_defconfig" + +# boot image macros +BUILD_BOOT_IMG=1 +BUILD_INITRAMFS=1 + +# Apply the perf and debug fragments over the GKI defconfig for a hybrid approach +function build_defconfig_fragments() { + if [[ "${VARIANT}" =~ ^(perf_defconfig|debug_defconfig|debug-defconfig)$ ]]; then + echo "build_defconfig_fragments: Applying GKI and debug defconfigs" + apply_defconfig_fragment "${KERNEL_DIR}/arch/${ARCH}/configs/vendor"/${MSM_ARCH}.config vendor/${MSM_ARCH}_defconfig + + if [ "${VARIANT}" = perf_defconfig ]; then + return + fi + + apply_defconfig_fragment "${KERNEL_DIR}/arch/${ARCH}/configs/vendor"/${MSM_ARCH}_debug.config vendor/${MSM_ARCH}-debug_defconfig + else + echo "Variant '${VARIANT}' unsupported" + exit 1 + fi +} + +build_defconfig_fragments diff --git a/build.targets b/build.targets index da48e3ce71d9..bf489b5de4a7 100644 --- a/build.targets +++ b/build.targets @@ -1,4 +1,5 @@ build.config.msm.autogvm +build.config.msm.autoghgvm build.config.msm.pineapple build.config.msm.niobe build.config.msm.kalama diff --git a/modules.list.msm.autoghgvm b/modules.list.msm.autoghgvm new file mode 100644 index 000000000000..18a2b1c04c3c --- /dev/null +++ b/modules.list.msm.autoghgvm @@ -0,0 +1,22 @@ +# SPDX-License-Identifier: GPL-2.0-only +# Copyright (c) 2023, Qualcomm Innovation Center, Inc. All rights reserved. + +gh_arm_drv.ko +qcom-scm.ko +mem_buf_dev.ko +mem_buf.ko +qcom_wdt_core.ko +virtio_mmio.ko +virtio_blk.ko +rename_devices.ko +gh_msgq.ko +gh_dbl.ko +gh_rm_drv.ko +hvc_gunyah.ko +qcom_dma_heaps.ko +gh_virt_wdt.ko +gh_ctrl.ko +net_failover.ko +failover.ko +virtio_net.ko +virtio_input.ko diff --git a/modules.systemdlkm_blocklist.msm.autoghgvm b/modules.systemdlkm_blocklist.msm.autoghgvm new file mode 100644 index 000000000000..c2a067991945 --- /dev/null +++ b/modules.systemdlkm_blocklist.msm.autoghgvm @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0-only +# Copyright (c) 2023, Qualcomm Innovation Center, Inc. All rights reserved. + diff --git a/modules.vendor_blocklist.msm.autoghgvm b/modules.vendor_blocklist.msm.autoghgvm new file mode 100644 index 000000000000..da1235ad472f --- /dev/null +++ b/modules.vendor_blocklist.msm.autoghgvm @@ -0,0 +1,63 @@ +# SPDX-License-Identifier: GPL-2.0-only +# Copyright (c) 2023 Qualcomm Innovation Center, Inc. All rights reserved. + +blocklist 8250_of +blocklist adc-tm +blocklist atomic64_test +blocklist can-bcm +blocklist can-gw +blocklist can-raw +blocklist dummy-cpufreq +blocklist dummy_hcd +blocklist dummy_hcd +blocklist e4000 +blocklist fc0011 +blocklist fc0012 +blocklist fc0013 +blocklist fc2580 +blocklist hsi2s +blocklist it913x +blocklist kheaders +blocklist lkdtm +blocklist llcc_perfmon +blocklist locktorture +blocklist m88rs6000t +blocklist max2165 +blocklist mc44s803 +blocklist mmrm_test_module +blocklist msi001 +blocklist mt2060 +blocklist mt2063 +blocklist mt20xx +blocklist mt2131 +blocklist mt2266 +blocklist mxl301rf +blocklist qm1d1b0004 +blocklist qm1d1c0042 +blocklist qt1010 +blocklist r820t +blocklist rcutorture +blocklist rtc-test +blocklist si2157 +blocklist tda18212 +blocklist tda18218 +blocklist tda18250 +blocklist tda18271 +blocklist tda827x +blocklist tda8290 +blocklist tda9887 +blocklist tea5761 +blocklist tea5767 +blocklist test_user_copy +blocklist torture +blocklist tua9001 +blocklist tuner-simple +blocklist tuner-types +blocklist tuner-xc2028 +blocklist vmw_vsock_virtio_transport +blocklist vmw_vsock_virtio_transport_common +blocklist vsock +blocklist vsock_diag +blocklist xc4000 +blocklist xc5000 +blocklist limits_stat diff --git a/msm_kernel_lagvm.bzl b/msm_kernel_lagvm.bzl new file mode 100644 index 000000000000..974b08765160 --- /dev/null +++ b/msm_kernel_lagvm.bzl @@ -0,0 +1,415 @@ +load("//build/bazel_common_rules/dist:dist.bzl", "copy_to_dist_dir") +load("//build/kernel/kleaf:constants.bzl", "aarch64_outs") +load( + "//build/kernel/kleaf:kernel.bzl", + "kernel_build", + "kernel_build_config", + "kernel_compile_commands", + "kernel_images", + "kernel_modules_install", + "kernel_uapi_headers_cc_library", + "merged_kernel_uapi_headers", + "super_image", + "unsparsed_image", +) +load( + "//build:msm_kernel_extensions.bzl", + "define_extras", + "get_build_config_fragments", + "get_dtb_list", + "get_dtbo_list", + "get_dtstree", + "get_gki_ramdisk_prebuilt_binary", + "get_vendor_ramdisk_binaries", +) +load("@bazel_skylib//rules:write_file.bzl", "write_file") +load(":msm_common.bzl", "define_top_level_config", "gen_config_without_source_lines", "get_out_dir") +load(":msm_dtc.bzl", "define_dtc_dist") +load(":avb_boot_img.bzl", "avb_sign_boot_image") +load(":image_opts.bzl", "boot_image_opts") +load(":target_variants.bzl", "lxc_variants") +load(":modules.bzl", "get_gki_modules_list") + +def _define_build_config( + msm_target, + target, + variant, + boot_image_opts = boot_image_opts(), + build_config_fragments = []): + """Creates a kernel_build_config for an MSM target + + Creates a `kernel_build_config` for input to a `kernel_build` rule. + + Args: + msm_target: name of target platform (e.g. "kalama") + variant: variant of kernel to build (e.g. "gki") + """ + + write_file( + name = "{}_build_config_bazel".format(target), + out = "build.config.msm.{}.generated".format(target), + content = [ + 'KERNEL_DIR="msm-kernel"', + "VARIANTS=({})".format(" ".join([v.replace("-", "_") for v in lxc_variants])), + "MSM_ARCH={}".format(msm_target.replace("-", "_")), + "VARIANT={}".format(variant.replace("-", "_")), + "ABL_SRC=bootable/bootloader/edk2", + "BOOT_IMAGE_HEADER_VERSION={}".format(boot_image_opts.boot_image_header_version), + "BASE_ADDRESS=0x%X" % boot_image_opts.base_address, + "PAGE_SIZE={}".format(boot_image_opts.page_size), + "BUILD_VENDOR_DLKM=1", + "PREPARE_SYSTEM_DLKM=1", + "SUPER_IMAGE_SIZE=0x%X" % boot_image_opts.super_image_size, + "TRIM_UNUSED_MODULES=1", + "BUILD_INIT_BOOT_IMG=1", + "LZ4_RAMDISK={}".format(int(boot_image_opts.lz4_ramdisk)), + '[ -z "$DT_OVERLAY_SUPPORT" ] && DT_OVERLAY_SUPPORT=1', + '[ "$KERNEL_CMDLINE_CONSOLE_AUTO" != "0" ] && KERNEL_VENDOR_CMDLINE+=\' earlycon={} \''.format(boot_image_opts.earlycon_addr), + "KERNEL_VENDOR_CMDLINE+=' {} '".format(" ".join(boot_image_opts.kernel_vendor_cmdline_extras)), + "VENDOR_BOOTCONFIG+='androidboot.first_stage_console=1 androidboot.hardware=qcom_kp'", + "", # Needed for newline at end of file + ], + ) + + top_level_config = define_top_level_config(target) + common_config = gen_config_without_source_lines("build.config.common", target) + + # Concatenate build config fragments to form the final config + kernel_build_config( + name = "{}_build_config".format(target), + srcs = [ + # do not sort + top_level_config, + "build.config.constants", + common_config, + "build.config.aarch64", + ":{}_build_config_bazel".format(target), + ] + [fragment for fragment in build_config_fragments] + [ + "build.config.msm.common", + "build.config.msm.autoghgvm", + ], + ) + + board_cmdline_extras = " ".join(boot_image_opts.board_kernel_cmdline_extras) + if board_cmdline_extras: + write_file( + name = "{}_extra_cmdline".format(target), + out = "board_extra_cmdline_{}".format(target), + content = [board_cmdline_extras, ""], + ) + + board_bc_extras = " ".join(boot_image_opts.board_bootconfig_extras) + if board_bc_extras: + write_file( + name = "{}_extra_bootconfig".format(target), + out = "board_extra_bootconfig_{}".format(target), + content = [board_bc_extras, ""], + ) + +def _define_kernel_build( + target, + in_tree_module_list, + dtb_list, + dtbo_list, + dtstree): + """Creates a `kernel_build` and other associated definitions + + This is where the main kernel build target is created (e.g. `//msm-kernel:kalama_gki`). + Many other rules will take this `kernel_build` as an input. + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + in_tree_module_list: list of in-tree modules + dtb_list: device tree blobs expected to be built + dtbo_list: device tree overlay blobs expected to be built + """ + out_list = [".config", "Module.symvers"] + + if dtb_list: + out_list += dtb_list + if dtbo_list: + out_list += dtbo_list + + # Add basic kernel outputs + out_list += aarch64_outs + + # Remove unused compressed formats + out_list.remove("Image.lz4") + out_list.remove("Image.gz") + + kernel_build( + name = target, + module_outs = in_tree_module_list, + module_implicit_outs = get_gki_modules_list("arm64"), + outs = out_list, + build_config = ":{}_build_config".format(target), + dtstree = dtstree, + kmi_symbol_list = None, + additional_kmi_symbol_lists = None, + abi_definition = None, + visibility = ["//visibility:public"], + ) + + kernel_modules_install( + name = "{}_modules_install".format(target), + kernel_build = ":{}".format(target), + ) + + merged_kernel_uapi_headers( + name = "{}_merged_kernel_uapi_headers".format(target), + kernel_build = ":{}".format(target), + ) + + kernel_compile_commands( + name = "{}_compile_commands".format(target), + kernel_build = ":{}".format(target), + ) + +def _define_image_build( + target, + msm_target, + base_kernel, + build_boot = True, + build_dtbo = False, + build_initramfs = False, + boot_image_opts = boot_image_opts(), + boot_image_outs = None, + dtbo_list = [], + vendor_ramdisk_binaries = None, + gki_ramdisk_prebuilt_binary = None, + in_tree_module_list = []): + """Creates a `kernel_images` target which will generate bootable device images + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + msm_target: name of target platform (e.g. "kalama") + base_kernel: kernel_build base kernel + build_boot: whether to build a boot image + build_dtbo: whether to build a dtbo image + build_initramfs: whether to build an initramfs image + boot_image_outs: boot image outputs, + dtbo_list: list of device tree overlay blobs to be built into `dtbo.img` + vendor_ramdisk_binaries: ramdisk binaries (cpio archives) + """ + + # Generate the vendor_dlkm list + native.genrule( + name = "{}_vendor_dlkm_modules_list_generated".format(target), + srcs = [], + outs = ["modules.list.vendor_dlkm.{}".format(target)], + cmd_bash = """ + touch "$@" + for module in {mod_list}; do + basename "$$module" >> "$@" + done + """.format(mod_list = " ".join(in_tree_module_list)), + ) + + kernel_images( + name = "{}_images".format(target), + kernel_modules_install = ":{}_modules_install".format(target), + kernel_build = ":{}".format(target), + base_kernel_images = "{}_images".format(base_kernel), + build_boot = build_boot, + build_dtbo = build_dtbo, + build_initramfs = build_initramfs, + build_vendor_boot = False, + build_vendor_kernel_boot = False, + build_vendor_dlkm = False, + build_system_dlkm = False, + modules_list = "modules.list.msm.{}".format(msm_target), + system_dlkm_modules_list = "android/gki_system_dlkm_modules", + vendor_dlkm_modules_list = ":{}_vendor_dlkm_modules_list_generated".format(target), + system_dlkm_modules_blocklist = "modules.systemdlkm_blocklist.msm.{}".format(msm_target), + vendor_dlkm_modules_blocklist = "modules.vendor_blocklist.msm.{}".format(msm_target), + dtbo_srcs = [":{}/".format(target) + d for d in dtbo_list] if dtbo_list else None, + vendor_ramdisk_binaries = vendor_ramdisk_binaries, + gki_ramdisk_prebuilt_binary = gki_ramdisk_prebuilt_binary, + boot_image_outs = boot_image_outs, + deps = [ + "modules.list.msm.{}".format(msm_target), + "modules.vendor_blocklist.msm.{}".format(msm_target), + "modules.systemdlkm_blocklist.msm.{}".format(msm_target), + "android/gki_system_dlkm_modules", + ], + ) + + if build_boot: + artifacts = "{}_images".format(target) + else: + artifacts = "{}_gki_artifacts".format(base_kernel) + + avb_sign_boot_image( + name = "{}_avb_sign_boot_image".format(target), + artifacts = artifacts, + avbtool = "//prebuilts/kernel-build-tools:linux-x86/bin/avbtool", + key = "//tools/mkbootimg:gki/testdata/testkey_rsa4096.pem", + props = [ + "com.android.build.boot.os_version:13", + "com.android.build.boot.security_patch:2023-05-05", + ], + boot_partition_size = int(boot_image_opts.boot_partition_size), + ) + + native.filegroup( + name = "{}_system_dlkm_image_file".format(target), + srcs = ["{}_images".format(base_kernel)], + output_group = "system_dlkm.img", + ) + + native.filegroup( + name = "{}_vendor_dlkm_image_file".format(target), + srcs = [":{}_images".format(target)], + output_group = "vendor_dlkm.img", + ) + + super_image( + name = "{}_super_image".format(target), + system_dlkm_image = ":{}_system_dlkm_image_file".format(target), + vendor_dlkm_image = ":{}_vendor_dlkm_image_file".format(target), + ) + + unsparsed_image( + name = "{}_unsparsed_image".format(target), + src = "{}_super_image".format(target), + out = "super_unsparsed.img", + ) + +def _define_kernel_dist( + target, + msm_target, + variant, + boot_image_opts = boot_image_opts()): + """Creates distribution targets for kernel builds + + When Bazel builds everything, the outputs end up buried in `bazel-bin`. + These rules are used to copy the build artifacts to `out/msm-kernel-/dist/` + with proper permissions, etc. + + Args: + target: name of main Bazel target (e.g. `kalama_gki`) + msm_target: name of just the platform target (e.g. `kalama`) + variant: name of just the variant (e.g. `gki`) + """ + + dist_dir = get_out_dir(msm_target, variant) + "/dist" + + msm_dist_targets = [ + # do not sort + ":{}".format(target), + ":{}_images".format(target), + ":{}_merged_kernel_uapi_headers".format(target), + ":{}_build_config".format(target), + ] + + copy_to_dist_dir( + name = "{}_dist".format(target), + data = msm_dist_targets, + dist_dir = dist_dir, + flat = True, + wipe_dist_dir = True, + allow_duplicate_filenames = True, + mode_overrides = { + # do not sort + "**/*.elf": "755", + "**/vmlinux": "755", + "**/Image": "755", + "**/*.dtb*": "755", + "**/LinuxLoader*": "755", + "**/*": "644", + }, + log = "info", + ) + +def _define_uapi_library(target): + """Define a cc_library for userspace programs to use + + Args: + target: kernel_build target name (e.g. "kalama_gki") + """ + kernel_uapi_headers_cc_library( + name = "{}_uapi_header_library".format(target), + kernel_build = ":{}".format(target), + ) + +def define_msm_lagvm( + msm_target, + variant, + in_tree_module_list, + boot_image_opts = boot_image_opts()): + """Top-level kernel build definition macro for an MSM platform + + Args: + msm_target: name of target platform (e.g. "kalama") + variant: variant of kernel to build (e.g. "gki") + in_tree_module_list: list of in-tree modules + boot_image_header_version: boot image header version (for `boot.img`) + base_address: edk2 base address + page_size: kernel page size + super_image_size: size of super image partition + lz4_ramdisk: whether to use an lz4-compressed ramdisk + """ + + if not variant in lxc_variants: + fail("{} not defined in target_variants.bzl lxc_variants!".format(variant)) + + # Enforce format of "//msm-kernel:target-foo_variant-bar" (underscore is the delimeter + # between target and variant) + target = msm_target.replace("_", "-") + "_" + variant.replace("_", "-") + + # Always set base_kernel to kernel_aarch64 + base_kernel = "//common:kernel_aarch64" + + lxc_target = msm_target.split("-")[0] + + dtb_list = get_dtb_list(lxc_target) + dtbo_list = get_dtbo_list(lxc_target) + dtstree = get_dtstree(lxc_target) + vendor_ramdisk_binaries = get_vendor_ramdisk_binaries(target) + gki_ramdisk_prebuilt_binary = get_gki_ramdisk_prebuilt_binary() + build_config_fragments = get_build_config_fragments(lxc_target) + + _define_build_config( + lxc_target, + target, + variant, + boot_image_opts = boot_image_opts, + build_config_fragments = build_config_fragments, + ) + + _define_kernel_build( + target, + in_tree_module_list, + dtb_list, + dtbo_list, + dtstree, + ) + + _define_image_build( + target, + msm_target, + base_kernel, + # When building a GKI target, we take the kernel and boot.img directly from + # common, so no need to build here. + build_boot = True, + build_dtbo = True, + build_initramfs = True, + dtbo_list = dtbo_list, + vendor_ramdisk_binaries = vendor_ramdisk_binaries, + boot_image_opts = boot_image_opts, + boot_image_outs = None if dtb_list else ["boot.img", "init_boot.img"], + in_tree_module_list = in_tree_module_list, + ) + + _define_kernel_dist( + target, + msm_target, + variant, + boot_image_opts = boot_image_opts, + ) + + _define_uapi_library(target) + + define_dtc_dist(target, msm_target, variant) + + define_extras(target) diff --git a/msm_platforms.bzl b/msm_platforms.bzl index bbd831369384..4cad2c5facda 100644 --- a/msm_platforms.bzl +++ b/msm_platforms.bzl @@ -1,5 +1,6 @@ load(":gen3auto.bzl", "define_gen3auto") load(":autogvm.bzl", "define_autogvm") +load(":autoghgvm.bzl", "define_autoghgvm") load(":autogvm_lxc.bzl", "define_autogvm_lxc") load(":gen4auto_lxc.bzl", "define_gen4auto_lxc") load(":sdmsteppeauto.bzl", "define_sdmsteppeauto") @@ -19,6 +20,7 @@ def define_msm_platforms(): define_signing_keys() define_gen3auto() define_autogvm() + define_autoghgvm() define_autogvm_lxc() define_gen4auto_lxc() define_sdmsteppeauto() diff --git a/target_variants.bzl b/target_variants.bzl index 74296c51f0eb..35b5311cd1b1 100644 --- a/target_variants.bzl +++ b/target_variants.bzl @@ -23,6 +23,7 @@ lxc_variants = [ lxc_targets = [ # keep sorted + "autoghgvm", "autogvm", "gen4auto", ]