commit 51dbb72a0420a4b04a294c639855e5bfa9fde05a Author: Łukasz Wojniłowicz <lukasz.wojnilowicz(a)gmail.com&gt; Date: Mon Sep 11 18:35:08 2023 +0200 Fix build on kernel-6.5.2 fix-build-issues.patch | 7026 ++++++++++++++------ ...90.151.patch => import-files-from-390.157.patch | 2637 +++++++- kernel-6.3.1.patch | 108 + kernel-6.5.2.patch | 77 + nvidia-340xx-kmod.spec | 17 +- 5 files changed, 7637 insertions(+), 2228 deletions(-) --- diff --git a/fix-build-issues.patch b/fix-build-issues.patch index b49fe90..e3e1ccd 100644 --- a/fix-build-issues.patch +++ b/fix-build-issues.patch @@ -1,2114 +1,5310 @@ -diff -Naur a/kernel/conftest.Kbuild b/kernel/conftest.Kbuild ---- a/kernel/conftest.Kbuild 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/conftest.Kbuild 2022-08-28 09:42:35.540184302 +0200 -@@ -0,0 +1,241 @@ -+NV_CONFTEST_GENERIC_COMPILE_TESTS += drm_available -+NV_CONFTEST_GENERIC_COMPILE_TESTS += drm_atomic_available -+NV_CONFTEST_GENERIC_COMPILE_TESTS += dom0_kernel_present -+NV_CONFTEST_GENERIC_COMPILE_TESTS += nvmap_support -+ -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += remap_pfn_range -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += vmap -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += set_pages_uc -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += set_memory_uc -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += set_memory_array_uc -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += change_page_attr -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_get_class -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_choose_state -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += vm_insert_page -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += acquire_console_sem -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += console_lock -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += kmem_cache_create -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += kmem_cache_create_usercopy -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += on_each_cpu -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += smp_call_function -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_evaluate_integer -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_cache -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_nocache -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_wc -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_walk_namespace -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_domain_nr -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_dma_mapping_error -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += file_operations -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_ops -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += sg_alloc_table -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += sg_init_table -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_get_domain_bus_and_slot -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_num_physpages -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_create_data -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pde_data -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += PDE_DATA -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_remove -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pm_vt_switch_required -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_save_state -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_pci_set_busid -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += write_cr4 -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += for_each_online_node -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += node_end_pfn -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_user_pages -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_user_pages_remote -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += register_cpu_notifier -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += cpuhp_setup_state -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_get_pci_dev -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_pci_init -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_legacy_pci_init -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += timer_setup -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += do_gettimeofday -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_gem_object_put_unlocked -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += efi_enabled -+ -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_gem_object_get -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_atomic_state_ref_counting -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_gem_object_lookup -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_dev_put -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_framebuffer_get -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_connector_for_each_possible_encoder -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += vga_tryget -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_bus_get_device -+ -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += remap_page_range -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += address_space_init_once -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += kbasename -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += fatal_signal_pending -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += list_cut_position -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += vzalloc -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += wait_on_bit_lock_argument_count -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += bitmap_clear -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += usleep_range -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += radix_tree_empty -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += radix_tree_replace_slot -+NV_CONFTEST_FUNCTION_COMPILE_TESTS += ktime_get_raw_ts64 -+ -+NV_CONFTEST_SYMBOL_COMPILE_TESTS += efi_enabled -+NV_CONFTEST_SYMBOL_COMPILE_TESTS += export_symbol_gpl_conftest -+ -+NV_CONFTEST_TYPE_COMPILE_TESTS += i2c_adapter -+NV_CONFTEST_TYPE_COMPILE_TESTS += pm_message_t -+NV_CONFTEST_TYPE_COMPILE_TESTS += irq_handler_t -+NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_device_ops -+NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_op_remove -+NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_device_id -+NV_CONFTEST_TYPE_COMPILE_TESTS += outer_flush_all -+NV_CONFTEST_TYPE_COMPILE_TESTS += proc_dir_entry -+NV_CONFTEST_TYPE_COMPILE_TESTS += scatterlist -+NV_CONFTEST_TYPE_COMPILE_TESTS += sg_table -+NV_CONFTEST_TYPE_COMPILE_TESTS += file_inode -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_present -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_has_bus_type -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_has_get_irq -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_has_get_name -+NV_CONFTEST_TYPE_COMPILE_TESTS += vm_fault_t -+NV_CONFTEST_TYPE_COMPILE_TESTS += vm_fault_present -+NV_CONFTEST_TYPE_COMPILE_TESTS += vm_fault_has_address -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_unload_has_int_return_type -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_legacy_feature_bit_present -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_prime_flag_present -+ -+NV_CONFTEST_TYPE_COMPILE_TESTS += timeval -+NV_CONFTEST_TYPE_COMPILE_TESTS += mm_has_mmap_lock -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_gem_object_vmap_has_map_arg -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_device_has_pdev -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_mode_object_find_has_file_priv_arg -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_prime_pages_to_sg_has_drm_device_arg -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_gem_object_has_resv -+ -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_gem_prime_export_has_dev_arg -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_has_gem_prime_callbacks -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_has_gem_free_object -+NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_has_gem_prime_res_obj -+NV_CONFTEST_TYPE_COMPILE_TESTS += vmalloc_has_pgprot_t_arg -+ -+NV_CONFTEST_TYPE_COMPILE_TESTS += vm_operations_struct -+NV_CONFTEST_TYPE_COMPILE_TESTS += task_struct -+NV_CONFTEST_TYPE_COMPILE_TESTS += kuid_t -+NV_CONFTEST_TYPE_COMPILE_TESTS += fault_flags -+NV_CONFTEST_TYPE_COMPILE_TESTS += atomic64_type -+NV_CONFTEST_TYPE_COMPILE_TESTS += address_space -+NV_CONFTEST_TYPE_COMPILE_TESTS += backing_dev_info -+NV_CONFTEST_TYPE_COMPILE_TESTS += mm_context_t -+NV_CONFTEST_TYPE_COMPILE_TESTS += vm_ops_fault_removed_vma_arg -+NV_CONFTEST_TYPE_COMPILE_TESTS += proc_ops -+NV_CONFTEST_TYPE_COMPILE_TESTS += pnv_npu2_init_context -+NV_CONFTEST_TYPE_COMPILE_TESTS += kmem_cache_has_kobj_remove_work -+NV_CONFTEST_TYPE_COMPILE_TESTS += sysfs_slab_unlink -+ -+NV_CONFTEST_MACRO_COMPILE_TESTS += INIT_WORK -+ -+# The conftest.sh script tests various aspects of the target kernel. -+# The per-module Kbuild files included above should: -+# -+# - Append to the NV_CONFTEST_*_COMPILE_TESTS variables to indicate -+# which conftests they require. -+# - Append to the NV_OBJECTS_DEPEND_ON_CONFTEST variable any object files -+# that depend on conftest. +diff -Naur a/kernel/conftest.sh.orig b/kernel/conftest.sh.orig +--- a/kernel/conftest.sh.orig 1970-01-01 01:00:00.000000000 +0100 ++++ b/kernel/conftest.sh.orig 2023-03-04 13:47:16.298195303 +0100 +@@ -0,0 +1,5078 @@ ++#!/bin/sh ++ ++PATH="${PATH}:/bin:/sbin:/usr/bin" ++ ++# make sure we are in the directory containing this script ++SCRIPTDIR=`dirname $0` ++cd $SCRIPTDIR ++ +# -+# The conftest machinery below will run the requested tests and -+# generate the appropriate header files. ++# HOSTCC vs. CC - if a conftest needs to build and execute a test ++# binary, like get_uname, then $HOSTCC needs to be used for this ++# conftest in order for the host/build system to be able to execute ++# it in X-compile environments. ++# In all other cases, $CC should be used to minimize the risk of ++# false failures due to conflicts with architecture specific header ++# files. +# ++CC="$1" ++HOSTCC="$2" ++ARCH=$3 ++ISYSTEM=`$CC -print-file-name=include 2> /dev/null` ++SOURCES=$4 ++HEADERS=$SOURCES/include ++OUTPUT=$5 ++XEN_PRESENT=1 ++PREEMPT_RT_PRESENT=0 ++KERNEL_ARCH="$ARCH" ++ ++if [ "$ARCH" = "i386" -o "$ARCH" = "x86_64" ]; then ++ if [ -d "$SOURCES/arch/x86" ]; then ++ KERNEL_ARCH="x86" ++ fi ++fi + -+CC ?= cc -+HOST_CC ?= $(CC) -+LD ?= ld ++HEADERS_ARCH="$SOURCES/arch/$KERNEL_ARCH/include" ++ ++# VGX_BUILD parameter defined only for VGX builds (vGPU Host driver) ++# VGX_KVM_BUILD parameter defined only vGPU builds on KVM hypervisor ++# GRID_BUILD parameter defined only for GRID builds (GRID Guest driver) ++ ++test_xen() { ++ # ++ # Determine if the target kernel is a Xen kernel. It used to be ++ # sufficient to check for CONFIG_XEN, but the introduction of ++ # modular para-virtualization (CONFIG_PARAVIRT, etc.) and ++ # Xen guest support, it is no longer possible to determine the ++ # target environment at build time. Therefore, if both ++ # CONFIG_XEN and CONFIG_PARAVIRT are present, text_xen() treats ++ # the kernel as a stand-alone kernel. ++ # ++ if ! test_configuration_option CONFIG_XEN || ++ test_configuration_option CONFIG_PARAVIRT; then ++ XEN_PRESENT=0 ++ fi ++} + -+NV_CONFTEST_SCRIPT := $(src)/conftest.sh -+NV_CONFTEST_HEADER := $(obj)/conftest/headers.h ++append_conftest() { ++ # ++ # Echo data from stdin: this is a transitional function to make it easier ++ # to port conftests from drivers with parallel conftest generation to ++ # older driver versions ++ # + -+NV_CONFTEST_CMD := /bin/sh $(NV_CONFTEST_SCRIPT) \ -+ "$(CC)" "$(HOST_CC)" $(ARCH) $(KERNEL_SOURCES) $(KERNEL_OUTPUT) ++ while read LINE; do ++ echo ${LINE} ++ done ++} + -+NV_CONFTEST_CFLAGS := $(shell $(NV_CONFTEST_CMD) build_cflags) ++translate_and_find_header_files() { ++ # Inputs: ++ # $1: a parent directory (full path), in which to search ++ # $2: a list of relative file paths ++ # ++ # This routine creates an upper case, underscore version of each of the ++ # relative file paths, and uses that as the token to either define or ++ # undefine in a C header file. For example, linux/fence.h becomes ++ # NV_LINUX_FENCE_H_PRESENT, and that is either defined or undefined, in the ++ # output (which goes to stdout, just like the rest of this file). ++ ++ local parent_dir=$1 ++ shift ++ ++ for file in $@; do ++ local file_define=NV_`echo $file | tr '/.' '_' | tr '-' '_' | tr 'a-z' 'A-Z'`_PRESENT ++ if [ -f $parent_dir/$file -o -f $OUTPUT/include/$file ]; then ++ echo "#define $file_define" ++ else ++ echo "#undef $file_define" ++ fi ++ done ++} + -+NV_CONFTEST_COMPILE_TEST_HEADERS := $(obj)/conftest/macros.h -+NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/functions.h -+NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/symbols.h -+NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/types.h -+NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/generic.h ++test_headers() { ++ # ++ # Determine which header files (of a set that may or may not be ++ # present) are provided by the target kernel. ++ # ++ FILES="acpi/video.h" ++ FILES="$FILES asm/system.h" ++ FILES="$FILES drm/drmP.h" ++ FILES="$FILES drm/drm_auth.h" ++ FILES="$FILES drm/drm_gem.h" ++ FILES="$FILES drm/drm_crtc.h" ++ FILES="$FILES drm/drm_atomic.h" ++ FILES="$FILES drm/drm_atomic_helper.h" ++ FILES="$FILES drm/drm_encoder.h" ++ FILES="$FILES drm/drm_atomic_uapi.h" ++ FILES="$FILES drm/drm_drv.h" ++ FILES="$FILES drm/drm_framebuffer.h" ++ FILES="$FILES drm/drm_connector.h" ++ FILES="$FILES drm/drm_probe_helper.h" ++ FILES="$FILES drm/drm_prime.h" ++ FILES="$FILES drm/drm_plane.h" ++ FILES="$FILES drm/drm_vblank.h" ++ FILES="$FILES drm/drm_file.h" ++ FILES="$FILES drm/drm_ioctl.h" ++ FILES="$FILES drm/drm_device.h" ++ FILES="$FILES generated/autoconf.h" ++ FILES="$FILES generated/compile.h" ++ FILES="$FILES generated/utsrelease.h" ++ FILES="$FILES linux/efi.h" ++ FILES="$FILES linux/kconfig.h" ++ FILES="$FILES linux/screen_info.h" ++ FILES="$FILES linux/semaphore.h" ++ FILES="$FILES linux/printk.h" ++ FILES="$FILES linux/ratelimit.h" ++ FILES="$FILES linux/prio_tree.h" ++ FILES="$FILES linux/log2.h" ++ FILES="$FILES linux/of.h" ++ FILES="$FILES linux/bug.h" ++ FILES="$FILES linux/sched/signal.h" ++ FILES="$FILES linux/sched/task.h" ++ FILES="$FILES linux/sched/task_stack.h" ++ FILES="$FILES xen/ioemu.h" ++ FILES="$FILES linux/fence.h" ++ FILES="$FILES linux/ktime.h" ++ FILES="$FILES linux/dma-resv.h" ++ FILES="$FILES linux/dma-map-ops.h" ++ FILES="$FILES linux/stdarg.h" ++ FILES="$FILES linux/iosys-map.h" ++ ++ # Arch specific headers which need testing ++ FILES_ARCH="asm/book3s/64/hash-64k.h" ++ FILES_ARCH="$FILES_ARCH asm/set_memory.h" ++ FILES_ARCH="$FILES_ARCH asm/powernv.h" ++ FILES_ARCH="$FILES_ARCH asm/tlbflush.h" ++ FILES_ARCH="$FILES_ARCH asm/pgtable_types.h" ++ ++ translate_and_find_header_files $HEADERS $FILES ++ translate_and_find_header_files $HEADERS_ARCH $FILES_ARCH ++} + -+NV_CONFTEST_HEADERS := $(obj)/conftest/patches.h -+NV_CONFTEST_HEADERS += $(obj)/conftest/headers.h -+NV_CONFTEST_HEADERS += $(NV_CONFTEST_COMPILE_TEST_HEADERS) ++build_cflags() { ++ BASE_CFLAGS="-O2 -D__KERNEL__ \ ++-DKBUILD_BASENAME=\"#conftest$$\" -DKBUILD_MODNAME=\"#conftest$$\" \ ++-nostdinc -isystem $ISYSTEM" ++ ++ if [ "$OUTPUT" != "$SOURCES" ]; then ++ OUTPUT_CFLAGS="-I$OUTPUT/include2 -I$OUTPUT/include" ++ if [ -f "$OUTPUT/include/generated/autoconf.h" ]; then ++ AUTOCONF_FILE="$OUTPUT/include/generated/autoconf.h" ++ else ++ AUTOCONF_FILE="$OUTPUT/include/linux/autoconf.h" ++ fi ++ else ++ if [ -f "$HEADERS/generated/autoconf.h" ]; then ++ AUTOCONF_FILE="$HEADERS/generated/autoconf.h" ++ else ++ AUTOCONF_FILE="$HEADERS/linux/autoconf.h" ++ fi ++ fi ++ ++ test_xen ++ ++ if [ "$XEN_PRESENT" != "0" ]; then ++ MACH_CFLAGS="-I$HEADERS/asm/mach-xen" ++ fi ++ ++ SOURCE_HEADERS="$HEADERS" ++ SOURCE_ARCH_HEADERS="$SOURCES/arch/$KERNEL_ARCH/include" ++ OUTPUT_HEADERS="$OUTPUT/include" ++ OUTPUT_ARCH_HEADERS="$OUTPUT/arch/$KERNEL_ARCH/include" ++ ++ # Look for mach- directories on this arch, and add it to the list of ++ # includes if that platform is enabled in the configuration file, which ++ # may have a definition like this: ++ # #define CONFIG_ARCH_<MACHUPPERCASE> 1 ++ for _mach_dir in `ls -1d $SOURCES/arch/$KERNEL_ARCH/mach-* 2>/dev/null`; do ++ _mach=`echo $_mach_dir | \ ++ sed -e "s,$SOURCES/arch/$KERNEL_ARCH/mach-,," | \ ++ tr 'a-z' 'A-Z'` ++ grep "CONFIG_ARCH_$_mach \+1" $AUTOCONF_FILE > /dev/null 2>&1 ++ if [ $? -eq 0 ]; then ++ MACH_CFLAGS="$MACH_CFLAGS -I$_mach_dir/include" ++ fi ++ done ++ ++ if [ "$ARCH" = "arm" ]; then ++ MACH_CFLAGS="$MACH_CFLAGS -D__LINUX_ARM_ARCH__=7" ++ fi ++ ++ # Add the mach-default includes (only found on x86/older kernels) ++ MACH_CFLAGS="$MACH_CFLAGS -I$SOURCE_HEADERS/asm-$KERNEL_ARCH/mach-default" ++ MACH_CFLAGS="$MACH_CFLAGS -I$SOURCE_ARCH_HEADERS/asm/mach-default" ++ ++ CFLAGS="$BASE_CFLAGS $MACH_CFLAGS $OUTPUT_CFLAGS -include $AUTOCONF_FILE" ++ CFLAGS="$CFLAGS -I$SOURCE_HEADERS" ++ CFLAGS="$CFLAGS -I$SOURCE_HEADERS/uapi" ++ CFLAGS="$CFLAGS -I$SOURCE_HEADERS/xen" ++ CFLAGS="$CFLAGS -I$OUTPUT_HEADERS/generated/uapi" ++ CFLAGS="$CFLAGS -I$SOURCE_ARCH_HEADERS" ++ CFLAGS="$CFLAGS -I$SOURCE_ARCH_HEADERS/uapi" ++ CFLAGS="$CFLAGS -I$OUTPUT_ARCH_HEADERS/generated" ++ CFLAGS="$CFLAGS -I$OUTPUT_ARCH_HEADERS/generated/uapi" ++ ++ if [ -n "$BUILD_PARAMS" ]; then ++ CFLAGS="$CFLAGS -D$BUILD_PARAMS" ++ fi ++ ++ # Check if gcc supports asm goto and set CC_HAVE_ASM_GOTO if it does. ++ # Older kernels perform this check and set this flag in Kbuild, and since ++ # conftest.sh runs outside of Kbuild it ends up building without this flag. ++ # Starting with commit e9666d10a5677a494260d60d1fa0b73cc7646eb3 this test ++ # is done within Kconfig, and the preprocessor flag is no longer needed. ++ ++ GCC_GOTO_SH="$SOURCES/build/gcc-goto.sh" ++ ++ if [ -f "$GCC_GOTO_SH" ]; then ++ # Newer versions of gcc-goto.sh don't print anything on success, but ++ # this is okay, since it's no longer necessary to set CC_HAVE_ASM_GOTO ++ # based on the output of those versions of gcc-goto.sh. ++ if [ `/bin/sh "$GCC_GOTO_SH" "$CC"` = "y" ]; then ++ CFLAGS="$CFLAGS -DCC_HAVE_ASM_GOTO" ++ fi ++ fi ++ ++ # ++ # If CONFIG_HAVE_FENTRY is enabled and gcc supports -mfentry flags then set ++ # CC_USING_FENTRY and add -mfentry into cflags. ++ # ++ # linux/ftrace.h file indirectly gets included into the conftest source and ++ # fails to get compiled, because conftest.sh runs outside of Kbuild it ends ++ # up building without -mfentry and CC_USING_FENTRY flags. ++ # ++ grep "CONFIG_HAVE_FENTRY \+1" $AUTOCONF_FILE > /dev/null 2>&1 ++ if [ $? -eq 0 ]; then ++ echo "" > conftest$$.c ++ ++ $CC -mfentry -c -x c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o + ++ CFLAGS="$CFLAGS -mfentry -DCC_USING_FENTRY" ++ fi ++ fi ++} + -+# -+# Generate a header file for a single conftest compile test. Each compile test -+# header depends on conftest.sh, as well as the generated conftest/headers.h -+# file, which is included in the compile test preamble. -+# ++CONFTEST_PREAMBLE="#include \"conftest/headers.h\" ++ #if defined(NV_LINUX_KCONFIG_H_PRESENT) ++ #include <linux/kconfig.h> ++ #endif ++ #if defined(NV_GENERATED_AUTOCONF_H_PRESENT) ++ #include <generated/autoconf.h> ++ #else ++ #include <linux/autoconf.h> ++ #endif ++ #if defined(CONFIG_XEN) && \ ++ defined(CONFIG_XEN_INTERFACE_VERSION) && !defined(__XEN_INTERFACE_VERSION__) ++ #define __XEN_INTERFACE_VERSION__ CONFIG_XEN_INTERFACE_VERSION ++ #endif" ++ ++test_configuration_option() { ++ # ++ # Check to see if the given configuration option is defined ++ # ++ ++ get_configuration_option $1 >/dev/null 2>&1 ++ ++ return $? + -+$(obj)/conftest/compile-tests/%.h: $(NV_CONFTEST_SCRIPT) $(NV_CONFTEST_HEADER) -+ @mkdir -p $(obj)/conftest/compile-tests -+ @echo " CONFTEST: $(notdir $*)" -+ @$(NV_CONFTEST_CMD) compile_tests '$(NV_CONFTEST_CFLAGS)' \ -+ $(notdir $*) > $@ ++} + -+# -+# Concatenate a conftest/*.h header from its constituent compile test headers -+# -+# $(1): The name of the concatenated header -+# $(2): The list of compile tests that make up the header -+# ++compile_check_conftest() { ++ # ++ # Compile the current conftest C file and check+output the result ++ # ++ CODE="$1" ++ DEF="$2" ++ VAL="$3" ++ CAT="$4" + -+define NV_GENERATE_COMPILE_TEST_HEADER -+ $(obj)/conftest/$(1).h: $(addprefix $(obj)/conftest/compile-tests/,$(addsuffix .h,$(2))) -+ @mkdir -p $(obj)/conftest -+ @# concatenate /dev/null to prevent cat from hanging when $$^ is empty -+ @cat $$^ /dev/null > $$@ -+endef ++ echo "$CONFTEST_PREAMBLE ++ $CODE" > conftest$$.c + -+# -+# Generate the conftest compile test headers from the lists of compile tests -+# provided by the module-specific Kbuild files. -+# -+NV_CONFTEST_FUNCTION_COMPILE_TESTS ?= -+NV_CONFTEST_GENERIC_COMPILE_TESTS ?= -+NV_CONFTEST_MACRO_COMPILE_TESTS ?= -+NV_CONFTEST_SYMBOL_COMPILE_TESTS ?= -+NV_CONFTEST_TYPE_COMPILE_TESTS ?= -+ -+$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,functions,$(NV_CONFTEST_FUNCTION_COMPILE_TESTS))) -+$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,generic,$(NV_CONFTEST_GENERIC_COMPILE_TESTS))) -+$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,macros,$(NV_CONFTEST_MACRO_COMPILE_TESTS))) -+$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,symbols,$(NV_CONFTEST_SYMBOL_COMPILE_TESTS))) -+$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,types,$(NV_CONFTEST_TYPE_COMPILE_TESTS))) -+ -+$(obj)/conftest/patches.h: $(NV_CONFTEST_SCRIPT) -+ @mkdir -p $(obj)/conftest -+ @$(NV_CONFTEST_CMD) patch_check > $@ -+ -+$(obj)/conftest/headers.h: $(NV_CONFTEST_SCRIPT) -+ @mkdir -p $(obj)/conftest -+ @$(NV_CONFTEST_CMD) test_kernel_headers > $@ -+ -+clean-dirs := $(obj)/conftest -+ -+ -+# For any object files that depend on conftest, declare the dependency here. -+$(addprefix $(obj)/,$(NV_OBJECTS_DEPEND_ON_CONFTEST)): | $(NV_CONFTEST_HEADERS) -+ -+# Sanity checks of the build environment and target system/kernel -+ -+BUILD_SANITY_CHECKS = \ -+ cc_sanity_check \ -+ cc_version_check \ -+ dom0_sanity_check \ -+ xen_sanity_check \ -+ preempt_rt_sanity_check \ -+ vgpu_kvm_sanity_check -+ -+.PHONY: $(BUILD_SANITY_CHECKS) -+ -+$(BUILD_SANITY_CHECKS): -+ @$(NV_CONFTEST_CMD) $@ full_output -+ -+# Perform all sanity checks before generating the conftest headers -+ -+$(NV_CONFTEST_HEADERS): | $(BUILD_SANITY_CHECKS) -diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh ---- a/kernel/conftest.sh 2022-10-16 09:28:09.779225728 +0200 -+++ b/kernel/conftest.sh 2022-08-28 09:42:35.542184258 +0200 -@@ -113,6 +113,7 @@ - FILES="$FILES drm/drm_vblank.h" - FILES="$FILES drm/drm_file.h" - FILES="$FILES drm/drm_ioctl.h" -+ FILES="$FILES drm/drm_pci.h" - FILES="$FILES drm/drm_device.h" - FILES="$FILES generated/autoconf.h" - FILES="$FILES generated/compile.h" -@@ -121,6 +122,7 @@ - FILES="$FILES linux/kconfig.h" - FILES="$FILES linux/screen_info.h" - FILES="$FILES linux/semaphore.h" -+ FILES="$FILES linux/nvmap.h" - FILES="$FILES linux/printk.h" - FILES="$FILES linux/ratelimit.h" - FILES="$FILES linux/prio_tree.h" -@@ -133,6 +135,7 @@ - FILES="$FILES xen/ioemu.h" - FILES="$FILES linux/fence.h" - FILES="$FILES linux/ktime.h" -+ FILES="$FILES linux/file.h" - FILES="$FILES linux/dma-resv.h" - FILES="$FILES linux/dma-map-ops.h" - FILES="$FILES linux/stdarg.h" -@@ -144,6 +147,8 @@ - FILES_ARCH="$FILES_ARCH asm/powernv.h" - FILES_ARCH="$FILES_ARCH asm/tlbflush.h" - FILES_ARCH="$FILES_ARCH asm/pgtable_types.h" -+ FILES_ARCH="$FILES_ARCH asm/kmap_types.h" -+ FILES_ARCH="$FILES_ARCH asm/pgtable.h" - - translate_and_find_header_files $HEADERS $FILES - translate_and_find_header_files $HEADERS_ARCH $FILES_ARCH -@@ -664,6 +669,63 @@ - compile_check_conftest "$CODE" "NV_FOLLOW_PFN_PRESENT" "" "functions" - ;; - -+ vmap) ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ if [ "${CAT}" = "functions" ]; then ++ # ++ # The logic for "functions" compilation tests is inverted compared to ++ # other compilation steps: if the function is present, the code ++ # snippet will fail to compile because the function call won't match ++ # the prototype. If the function is not present, the code snippet ++ # will produce an object file with the function as an unresolved ++ # symbol. ++ # ++ echo "#undef ${DEF}" | append_conftest "${CAT}" ++ else ++ echo "#define ${DEF} ${VAL}" | append_conftest "${CAT}" ++ fi ++ return ++ else ++ if [ "${CAT}" = "functions" ]; then ++ echo "#define ${DEF} ${VAL}" | append_conftest "${CAT}" ++ else ++ echo "#undef ${DEF}" | append_conftest "${CAT}" ++ fi ++ return ++ fi ++} ++ ++export_symbol_present_conftest() { ++ # ++ # Check Module.symvers to see whether the given symbol is present. ++ # ++ ++ SYMBOL="$1" ++ TAB=' ' ++ ++ if grep -e "${TAB}${SYMBOL}${TAB}.*${TAB}EXPORT_SYMBOL.*\$" \ ++ "$OUTPUT/Module.symvers" >/dev/null 2>&1; then ++ echo "#define NV_IS_EXPORT_SYMBOL_PRESENT_$SYMBOL 1" | ++ append_conftest "symbols" ++ else ++ # May be a false negative if Module.symvers is absent or incomplete, ++ # or if the Module.symvers format changes. ++ echo "#define NV_IS_EXPORT_SYMBOL_PRESENT_$SYMBOL 0" | ++ append_conftest "symbols" ++ fi ++} ++ ++export_symbol_gpl_conftest() { ++ # ++ # Check Module.symvers to see whether the given symbol is present and its ++ # export type is GPL-only (including deprecated GPL-only symbols). ++ # ++ ++ SYMBOL="$1" ++ TAB=' ' ++ ++ if grep -e "${TAB}${SYMBOL}${TAB}.*${TAB}EXPORT_\(UNUSED_\)*SYMBOL_GPL\$" \ ++ "$OUTPUT/Module.symvers" >/dev/null 2>&1; then ++ echo "#define NV_IS_EXPORT_SYMBOL_GPL_$SYMBOL 1" | ++ append_conftest "symbols" ++ else ++ # May be a false negative if Module.symvers is absent or incomplete, ++ # or if the Module.symvers format changes. ++ echo "#define NV_IS_EXPORT_SYMBOL_GPL_$SYMBOL 0" | ++ append_conftest "symbols" ++ fi ++} ++ ++get_configuration_option() { ++ # ++ # Print the value of given configuration option, if defined ++ # ++ RET=1 ++ OPTION=$1 ++ ++ OLD_FILE="linux/autoconf.h" ++ NEW_FILE="generated/autoconf.h" ++ FILE="" ++ ++ if [ -f $HEADERS/$NEW_FILE -o -f $OUTPUT/include/$NEW_FILE ]; then ++ FILE=$NEW_FILE ++ elif [ -f $HEADERS/$OLD_FILE -o -f $OUTPUT/include/$OLD_FILE ]; then ++ FILE=$OLD_FILE ++ fi ++ ++ if [ -n "$FILE" ]; then ++ # ++ # We are looking at a configured source tree; verify ++ # that its configuration includes the given option ++ # via a compile check, and print the option's value. ++ # ++ ++ if [ -f $HEADERS/$FILE ]; then ++ INCLUDE_DIRECTORY=$HEADERS ++ elif [ -f $OUTPUT/include/$FILE ]; then ++ INCLUDE_DIRECTORY=$OUTPUT/include ++ else ++ return 1 ++ fi ++ ++ echo "#include <$FILE> ++ #ifndef $OPTION ++ #error $OPTION not defined! ++ #endif ++ ++ $OPTION ++ " > conftest$$.c ++ ++ $CC -E -P -I$INCLUDE_DIRECTORY -o conftest$$ conftest$$.c > /dev/null 2>&1 ++ ++ if [ -e conftest$$ ]; then ++ tr -d '\r\n\t ' < conftest$$ ++ RET=$? ++ fi ++ ++ rm -f conftest$$.c conftest$$ ++ else ++ CONFIG=$OUTPUT/.config ++ if [ -f $CONFIG ] && grep "^$OPTION=" $CONFIG; then ++ grep "^$OPTION=" $CONFIG | cut -f 2- -d "=" ++ RET=$? ++ fi ++ fi ++ ++ return $RET ++ ++} ++ ++compile_test() { ++ case "$1" in ++ set_memory_uc) ++ # ++ # Determine if the set_memory_uc() function is present. ++ # ++ CODE=" ++ #if defined(NV_ASM_SET_MEMORY_H_PRESENT) ++ #if defined(NV_ASM_PGTABLE_TYPES_H_PRESENT) ++ #include <asm/pgtable_types.h> ++ #endif ++ #include <asm/set_memory.h> ++ #else ++ #include <asm/cacheflush.h> ++ #endif ++ void conftest_set_memory_uc(void) { ++ set_memory_uc(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SET_MEMORY_UC_PRESENT" "" "functions" ++ ;; ++ ++ set_memory_array_uc) ++ # ++ # Determine if the set_memory_array_uc() function is present. ++ # ++ CODE=" ++ #if defined(NV_ASM_SET_MEMORY_H_PRESENT) ++ #if defined(NV_ASM_PGTABLE_TYPES_H_PRESENT) ++ #include <asm/pgtable_types.h> ++ #endif ++ #include <asm/set_memory.h> ++ #else ++ #include <asm/cacheflush.h> ++ #endif ++ void conftest_set_memory_array_uc(void) { ++ set_memory_array_uc(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SET_MEMORY_ARRAY_UC_PRESENT" "" "functions" ++ ;; ++ ++ sysfs_slab_unlink) ++ # ++ # Determine if the sysfs_slab_unlink() function is present. ++ # ++ # This test is useful to check for the presence a fix for the deferred ++ # kmem_cache destroy feature (see nvbug: 2543505). ++ # ++ # Added by commit d50d82faa0c9 ("slub: fix failure when we delete and ++ # create a slab cache") in 4.18 (2018-06-27). ++ # ++ CODE=" ++ #include <linux/slab.h> ++ void conftest_sysfs_slab_unlink(void) { ++ sysfs_slab_unlink(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SYSFS_SLAB_UNLINK_PRESENT" "" "functions" ++ ;; ++ ++ list_is_first) ++ # ++ # Determine if the list_is_first() function is present. ++ # ++ # Added by commit 0d29c2d43753 ("mm, compaction: Use free lists to quickly ++ # locate a migration source -fix") in linux-next tree ++ # ++ CODE=" ++ #include <linux/list.h> ++ void conftest_list_is_first(void) { ++ list_is_first(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_LIST_IS_FIRST_PRESENT" "" "functions" ++ ;; ++ ++ set_pages_uc) ++ # ++ # Determine if the set_pages_uc() function is present. ++ # ++ CODE=" ++ #if defined(NV_ASM_SET_MEMORY_H_PRESENT) ++ #if defined(NV_ASM_PGTABLE_TYPES_H_PRESENT) ++ #include <asm/pgtable_types.h> ++ #endif ++ #include <asm/set_memory.h> ++ #else ++ #include <asm/cacheflush.h> ++ #endif ++ void conftest_set_pages_uc(void) { ++ set_pages_uc(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SET_PAGES_UC_PRESENT" "" "functions" ++ ;; ++ ++ outer_flush_all) ++ # ++ # Determine if the outer_cache_fns struct has flush_all member. ++ # ++ CODE=" ++ #include <asm/outercache.h> ++ int conftest_outer_flush_all(void) { ++ return offsetof(struct outer_cache_fns, flush_all); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_OUTER_FLUSH_ALL_PRESENT" "" "types" ++ ;; ++ ++ change_page_attr) ++ # ++ # Determine if the change_page_attr() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/version.h> ++ #include <linux/utsname.h> ++ #include <linux/mm.h> ++ #include <asm/cacheflush.h> ++ void conftest_change_page_attr(void) { ++ change_page_attr(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_CHANGE_PAGE_ATTR_PRESENT" "" "functions" ++ ;; ++ ++ pci_get_class) ++ # ++ # Determine if the pci_get_class() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/pci.h> ++ void conftest_pci_get_class(void) { ++ pci_get_class(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_GET_CLASS_PRESENT" "" "functions" ++ ;; ++ ++ pci_get_domain_bus_and_slot) ++ # ++ # Determine if the pci_get_domain_bus_and_slot() function ++ # is present. ++ # ++ CODE=" ++ #include <linux/pci.h> ++ void conftest_pci_get_domain_bus_and_slot(void) { ++ pci_get_domain_bus_and_slot(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_GET_DOMAIN_BUS_AND_SLOT_PRESENT" "" "functions" ++ ;; ++ ++ pci_save_state) + # -+ # Determine if the vmap() function is present and how -+ # many arguments it takes. ++ # Determine the number of arguments of pci_(save|restore)_state(). ++ # The explicit buffer argument is only present on 2.6.9. Assume the ++ # interface is always present. + # + echo "$CONFTEST_PREAMBLE -+ #include <linux/vmalloc.h> -+ void conftest_vmap(void) { -+ vmap(); ++ #include <linux/pci.h> ++ void conftest_pci_save_state(void) { ++ pci_save_state(NULL); + }" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ -f conftest$$.o ]; then -+ echo "#undef NV_VMAP_PRESENT" | append_conftest "functions" ++ echo "#define NV_PCI_SAVE_STATE_ARGUMENT_COUNT 1" | append_conftest "functions" + rm -f conftest$$.o + return ++ else ++ echo "#define NV_PCI_SAVE_STATE_ARGUMENT_COUNT 2" | append_conftest "functions" ++ return + fi ++ ;; ++ ++ pci_bus_address) ++ # ++ # Determine if the pci_bus_address() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/pci.h> ++ void conftest_pci_bus_address(void) { ++ pci_bus_address(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_BUS_ADDRESS_PRESENT" "" "functions" ++ ;; ++ ++ remap_pfn_range) ++ # ++ # Determine if the remap_pfn_range() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_remap_pfn_range(void) { ++ remap_pfn_range(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_REMAP_PFN_RANGE_PRESENT" "" "functions" ++ ;; ++ ++ hash__remap_4k_pfn) ++ # ++ # Determine if the hash__remap_4k_pfn() function is ++ # present. ++ # hash__remap_4k_pfn was added by this commit: ++ # 2016-04-29 6cc1a0ee4ce29ad1cbdc622db6f9bc16d3056067 ++ # ++ CODE=" ++ #if defined(NV_ASM_BOOK3S_64_HASH_64K_H_PRESENT) ++ #include <linux/mm.h> ++ #include <asm/book3s/64/hash-64k.h> ++ #endif ++ void conftest_hash__remap_4k_pfn(void) { ++ hash__remap_4k_pfn(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_HASH__REMAP_4K_PFN_PRESENT" "" "functions" ++ ;; ++ ++ follow_pfn) ++ # ++ # Determine if the follow_pfn() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_follow_pfn(void) { ++ follow_pfn(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FOLLOW_PFN_PRESENT" "" "functions" ++ ;; ++ ++ i2c_adapter) ++ # ++ # Determine if the 'i2c_adapter' structure has the ++ # client_register() field. ++ # ++ CODE=" ++ #include <linux/i2c.h> ++ int conftest_i2c_adapter(void) { ++ return offsetof(struct i2c_adapter, client_register); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_I2C_ADAPTER_HAS_CLIENT_REGISTER" "" "types" ++ ;; + ++ pm_message_t) ++ # ++ # Determine if the 'pm_message_t' data type is present ++ # and if it as an 'event' member. ++ # + echo "$CONFTEST_PREAMBLE -+ #include <linux/vmalloc.h> -+ void *conftest_vmap(struct page **pages, int count) { -+ return vmap(pages, count); ++ #include <linux/pm.h> ++ void conftest_pm_message_t(pm_message_t state) { ++ pm_message_t *p = &state; + }" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ -f conftest$$.o ]; then -+ echo "#define NV_VMAP_PRESENT" | append_conftest "functions" -+ echo "#define NV_VMAP_ARGUMENT_COUNT 2" | append_conftest "functions" ++ echo "#define NV_PM_MESSAGE_T_PRESENT" | append_conftest "types" + rm -f conftest$$.o ++ else ++ echo "#undef NV_PM_MESSAGE_T_PRESENT" | append_conftest "types" ++ echo "#undef NV_PM_MESSAGE_T_HAS_EVENT" | append_conftest "types" + return + fi + + echo "$CONFTEST_PREAMBLE -+ #include <linux/vmalloc.h> -+ #include <linux/mm.h> -+ void *conftest_vmap(struct page **pages, int count) { -+ return vmap(pages, count, 0, PAGE_KERNEL); ++ #include <linux/pm.h> ++ int conftest_pm_message_t(void) { ++ return offsetof(pm_message_t, event); + }" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ -f conftest$$.o ]; then -+ echo "#define NV_VMAP_PRESENT" | append_conftest "functions" -+ echo "#define NV_VMAP_ARGUMENT_COUNT 4" | append_conftest "functions" ++ echo "#define NV_PM_MESSAGE_T_HAS_EVENT" | append_conftest "types" + rm -f conftest$$.o + return + else -+ echo "#error vmap() conftest failed!" | append_conftest "functions" ++ echo "#undef NV_PM_MESSAGE_T_HAS_EVENT" | append_conftest "types" + return + fi + ;; + - i2c_adapter) - # - # Determine if the 'i2c_adapter' structure has the -@@ -1112,6 +1174,16 @@ - compile_check_conftest "$CODE" "NV_CPUHP_SETUP_STATE_PRESENT" "" "functions" - ;; - -+ nvmap_support) -+ # check if nvmap is supported. -+ if [ -f nv-android.h ]; then -+ echo "#define HAVE_NV_ANDROID" | append_conftest "generic" -+ return -+ else -+ echo "#undef HAVE_NV_ANDROID" | append_conftest "generic" -+ fi ++ pci_choose_state) ++ # ++ # Determine if the pci_choose_state() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/pci.h> ++ void conftest_pci_choose_state(void) { ++ pci_choose_state(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_CHOOSE_STATE_PRESENT" "" "functions" + ;; + - acpi_evaluate_integer) - # - # Determine if the acpi_evaluate_integer() function is -@@ -1427,6 +1499,47 @@ - compile_check_conftest "$CODE" "NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL" "" "types" - ;; - -+ sg_init_table) ++ vm_insert_page) ++ # ++ # Determine if the vm_insert_page() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_vm_insert_page(void) { ++ vm_insert_page(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VM_INSERT_PAGE_PRESENT" "" "functions" ++ ;; ++ ++ irq_handler_t) + # -+ # Determine if the sg_init_table() function is present. ++ # Determine if the 'irq_handler_t' type is present and ++ # if it takes a 'struct ptregs *' argument. + # + echo "$CONFTEST_PREAMBLE -+ #include <linux/scatterlist.h> -+ void conftest_sg_init_table(struct scatterlist *sgl, -+ unsigned int nents) { -+ }" > conftest$$.c ++ #include <linux/interrupt.h> ++ irq_handler_t conftest_isr; ++ " > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ ! -f conftest$$.o ]; then -+ echo "#undef NV_SG_INIT_TABLE_PRESENT" | append_conftest "functions" ++ echo "#undef NV_IRQ_HANDLER_T_PRESENT" | append_conftest "types" ++ rm -f conftest$$.o + return -+ + fi ++ + rm -f conftest$$.o + + echo "$CONFTEST_PREAMBLE -+ #include <linux/types.h> -+ #include <linux/scatterlist.h> -+ void conftest_sg_init_table(struct scatterlist *sgl, -+ unsigned int nents) { -+ sg_init_table(); ++ #include <linux/interrupt.h> ++ irq_handler_t conftest_isr; ++ int conftest_irq_handler_t(int irq, void *arg) { ++ return conftest_isr(irq, arg); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_IRQ_HANDLER_T_PRESENT" | append_conftest "types" ++ echo "#define NV_IRQ_HANDLER_T_ARGUMENT_COUNT 2" | append_conftest "types" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/interrupt.h> ++ irq_handler_t conftest_isr; ++ int conftest_irq_handler_t(int irq, void *arg, struct pt_regs *regs) { ++ return conftest_isr(irq, arg, regs); + }" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ -f conftest$$.o ]; then -+ echo "#undef NV_SG_INIT_TABLE_PRESENT" | append_conftest "functions" ++ echo "#define NV_IRQ_HANDLER_T_PRESENT" | append_conftest "types" ++ echo "#define NV_IRQ_HANDLER_T_ARGUMENT_COUNT 3" | append_conftest "types" + rm -f conftest$$.o + return + else -+ echo "#define NV_SG_INIT_TABLE_PRESENT" | append_conftest "functions" ++ echo "#error irq_handler_t() conftest failed!" | append_conftest "types" + return + fi + ;; + - sg_table) - # - # Determine if the struct sg_table type is present. -@@ -1815,6 +1928,9 @@ - # - # Determine if the PDE_DATA() function is present. - # -+ # Added by commit d9dda78bad87 -+ # ("procfs: new helper - PDE_DATA(inode)") in v3.10 ++ request_threaded_irq) + # - CODE=" - #include <linux/proc_fs.h> - void conftest_PDE_DATA(void) { -@@ -2052,6 +2168,21 @@ - compile_check_conftest "$CODE" "NV_FILE_HAS_INODE" "" "types" - ;; - -+ drm_pci_set_busid) ++ # Determine if the request_threaded_irq() function is present. + # -+ # Determine if the drm_pci_set_busid function is present. ++ # added: 2009-03-23 3aa551c9b4c40018f0e261a178e3d25478dc04a9 + # + CODE=" -+ #if defined(NV_DRM_DRMP_H_PRESENT) -+ #include <drm/drmP.h> -+ #endif -+ void conftest_drm_pci_set_busid(void) { -+ drm_pci_set_busid(); ++ #include <linux/interrupt.h> ++ int conftest_request_threaded_irq(void) { ++ return request_threaded_irq(); + }" -+ -+ compile_check_conftest "$CODE" "NV_DRM_PCI_SET_BUSID_PRESENT" "" "functions" ++ compile_check_conftest "$CODE" "NV_REQUEST_THREADED_IRQ_PRESENT" "" "functions" + ;; + - xen_ioemu_inject_msi) - # - # Determine if the xen_ioemu_inject_msi() function is present. -@@ -3429,6 +3560,64 @@ - compile_check_conftest "$CODE" "NV_DRM_DRIVER_UNLOAD_HAS_INT_RETURN_TYPE" "" "types" - ;; - -+ drm_get_pci_dev) ++ acpi_device_ops) + # -+ # Determine if drm_get_pci_dev() is present. ++ # Determine if the 'acpi_device_ops' structure has ++ # a match() member. + # + CODE=" -+ #if defined(NV_DRM_DRMP_H_PRESENT) -+ #include <drm/drmP.h> -+ #endif -+ -+ #if defined(NV_DRM_DRM_PCI_H_PRESENT) -+ #include <drm/drm_pci.h> -+ #endif -+ -+ void conftest_drm_legacy_pci_init(void) { -+ drm_get_pci_dev(); ++ #include <linux/acpi.h> ++ int conftest_acpi_device_ops(void) { ++ return offsetof(struct acpi_device_ops, match); + }" + -+ compile_check_conftest "$CODE" "NV_DRM_GET_PCI_DEV_PRESENT" "" "functions" ++ compile_check_conftest "$CODE" "NV_ACPI_DEVICE_OPS_HAS_MATCH" "" "types" + ;; + -+ drm_pci_init) ++ acpi_op_remove) + # -+ # Determine if drm_pci_init() is present. ++ # Determine the number of arguments to pass to the ++ # 'acpi_op_remove' routine. + # ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/acpi.h> ++ ++ acpi_op_remove conftest_op_remove_routine; ++ ++ int conftest_acpi_device_ops_remove(struct acpi_device *device) { ++ return conftest_op_remove_routine(device); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT 1" | append_conftest "types" ++ return ++ fi ++ + CODE=" -+ #if defined(NV_DRM_DRMP_H_PRESENT) -+ #include <drm/drmP.h> -+ #endif ++ #include <linux/acpi.h> + -+ void conftest_drm_legacy_pci_init(void) { -+ drm_pci_init(); ++ acpi_op_remove conftest_op_remove_routine; ++ ++ int conftest_acpi_device_ops_remove(struct acpi_device *device, int type) { ++ return conftest_op_remove_routine(device, type); + }" + -+ compile_check_conftest "$CODE" "NV_DRM_PCI_INIT_PRESENT" "" "functions" ++ compile_check_conftest "$CODE" "NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT" "2" "types" + ;; + -+ drm_legacy_pci_init) -+ # -+ # Determine if drm_legacy_pci_init() is present. drm_pci_init() was -+ # deprecated and renamed to drm_legacy_pci_init by: ++ acpi_device_id) + # -+ # 2017-05-24 10631d724deff712343d96dd3017cd323349f761 ++ # Determine if the 'acpi_device_id' structure has ++ # a 'driver_data' member. + # + CODE=" -+ #if defined(NV_DRM_DRMP_H_PRESENT) -+ #include <drm/drmP.h> -+ #endif -+ -+ #if defined(NV_DRM_DRM_PCI_H_PRESENT) -+ #include <drm/drm_pci.h> -+ #endif -+ void conftest_drm_legacy_pci_init(void) { -+ drm_legacy_pci_init(); ++ #include <linux/acpi.h> ++ int conftest_acpi_device_id(void) { ++ return offsetof(struct acpi_device_id, driver_data); + }" + -+ compile_check_conftest "$CODE" "NV_DRM_LEGACY_PCI_INIT_PRESENT" "" "functions" ++ compile_check_conftest "$CODE" "NV_ACPI_DEVICE_ID_HAS_DRIVER_DATA" "" "types" + ;; + - kref_has_refcount_of_type_refcount_t) - CODE=" - #include <linux/kref.h> -@@ -3981,6 +4170,30 @@ - compile_check_conftest "$CODE" "NV_DMA_IS_DIRECT_PRESENT" "" "functions" - ;; - -+ drm_driver_legacy_feature_bit_present) ++ acquire_console_sem) + # -+ # Determine if the DRIVER_LEGACY feature bit is present, either as a -+ # preprocessor macro or in an enum. -+ # -+ # The DRIVER_* feature bits were changed from CPP macros to an enum -+ # with commit 0e2a933b02c972919f7478364177eb76cd4ae00d (2019-01-29). ++ # Determine if the acquire_console_sem() function ++ # is present. + # + CODE=" -+ #if defined(NV_DRM_DRMP_H_PRESENT) -+ #include <drm/drmP.h> -+ #endif ++ #include <linux/console.h> ++ void conftest_acquire_console_sem(void) { ++ acquire_console_sem(NULL); ++ }" + -+ #if defined(NV_DRM_DRM_DRV_H_PRESENT) -+ #include <drm/drm_drv.h> -+ #endif ++ compile_check_conftest "$CODE" "NV_ACQUIRE_CONSOLE_SEM_PRESENT" "" "functions" ++ ;; + -+ void conftest_drm_driver_legacy_feature_bit_present(struct drm_driver *drv) { -+ drv->driver_features = DRIVER_LEGACY; ++ console_lock) ++ # ++ # Determine if the console_lock() function is present. ++ # ++ CODE=" ++ #include <linux/console.h> ++ void conftest_console_lock(void) { ++ console_lock(NULL); + }" + -+ compile_check_conftest "$CODE" "NV_DRM_DRIVER_LEGACY_FEATURE_BIT_PRESENT" "" "types" ++ compile_check_conftest "$CODE" "NV_CONSOLE_LOCK_PRESENT" "" "functions" + ;; + - drm_driver_prime_flag_present) - # - # Determine whether driver feature flag DRIVER_PRIME is present. -diff -Naur a/kernel/dkms.conf b/kernel/dkms.conf ---- a/kernel/dkms.conf 2022-10-16 09:28:09.688227805 +0200 -+++ b/kernel/dkms.conf 2022-08-28 09:42:35.543184237 +0200 -@@ -1,7 +1,13 @@ -+if [ -x /usr/bin/nproc ]; then -+ num_cpu_cores=$(nproc) -+else -+ num_cpu_cores=1 -+fi ++ kmem_cache_create) ++ # ++ # Determine if the kmem_cache_create() function is ++ # present and how many arguments it takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/slab.h> ++ void conftest_kmem_cache_create(void) { ++ kmem_cache_create(); ++ }" > conftest$$.c + - PACKAGE_NAME="nvidia" - PACKAGE_VERSION="340.108" - BUILT_MODULE_NAME[0]="$PACKAGE_NAME" - DEST_MODULE_LOCATION[0]="/kernel/drivers/video" --MAKE[0]="make module KERNEL_UNAME=${kernelver}" -+MAKE[0]="make -j$num_cpu_cores module KERNEL_UNAME=${kernelver}" - CLEAN="make clean" - AUTOINSTALL="yes" -diff -Naur a/kernel/Makefile b/kernel/Makefile ---- a/kernel/Makefile 2022-10-16 09:28:09.686227851 +0200 -+++ b/kernel/Makefile 2022-08-28 09:42:35.539184324 +0200 -@@ -70,11 +70,11 @@ - MODULE_GLUE_OBJS := $(patsubst %.c,%.o,nv-frontend.c) - $(MODULE_NAME)-objs := $(MODULE_GLUE_OBJS) - else -- MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c) -+ MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c nvidia-drm-linux.c nvidia-drm-gem.c nvidia-drm-helper.c nvidia-drm-gem-user-memory.c) - $(MODULE_NAME)-objs := $(CORE_OBJS) $(MODULE_GLUE_OBJS) - endif - else -- MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c) $(patsubst %.c,%.o,nv-frontend.c) -+ MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c nvidia-drm-linux.c nvidia-drm-gem.c nvidia-drm-helper.c nvidia-drm-gem-user-memory.c) $(patsubst %.c,%.o,nv-frontend.c) - $(MODULE_NAME)-objs := $(CORE_OBJS) $(MODULE_GLUE_OBJS) - endif - -@@ -168,7 +168,7 @@ - EXTRA_CFLAGS += -DNV_BUILD_MODULE_INSTANCES=0 - endif - --EXTRA_CFLAGS += -UDEBUG -U_DEBUG -DNDEBUG -+EXTRA_CFLAGS += -UDEBUG -U_DEBUG -DNDEBUG -DNV_KERNEL_INTERFACE_LAYER - - # - # Include common definitions; we rely on the definition of the source path to -@@ -178,6 +178,7 @@ - - src ?= . - include $(src)/nvidia-modules-common.mk -+include $(src)/conftest.Kbuild - - # - # Generate multiple targets at runtime depending on the items present in -diff -Naur a/kernel/nv-acpi.c b/kernel/nv-acpi.c ---- a/kernel/nv-acpi.c 2022-10-16 09:28:09.690227759 +0200 -+++ b/kernel/nv-acpi.c 2022-10-16 09:27:14.547486369 +0200 -@@ -556,9 +556,11 @@ - - void NV_API_CALL nv_acpi_methods_init(NvU32 *handlesPresent) - { -+#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) - struct acpi_device *device = NULL; - RM_STATUS rmStatus; - int retVal = -1; -+#endif - - - if (!handlesPresent) // Caller passed us invalid pointer. -@@ -570,6 +572,7 @@ - NV_ACPI_WALK_NAMESPACE(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, - ACPI_UINT32_MAX, nv_acpi_find_methods, NULL, NULL); - -+#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) - if (nvif_handle) - { - *handlesPresent = NV_ACPI_NVIF_HANDLE_PRESENT; -@@ -596,6 +599,7 @@ - - } while (0); - } -+#endif - - if (wmmx_handle) - *handlesPresent = *handlesPresent | NV_ACPI_WMMX_HANDLE_PRESENT; -@@ -651,10 +655,12 @@ - - if (nvif_parent_gpu_handle == NULL) - return; -- -+#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) - acpi_bus_get_device(nvif_parent_gpu_handle, &device); - - nv_uninstall_notifier(device, nv_acpi_event); -+#endif ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#undef NV_KMEM_CACHE_CREATE_PRESENT" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/slab.h> ++ void conftest_kmem_cache_create(void) { ++ kmem_cache_create(NULL, 0, 0, 0L, NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_KMEM_CACHE_CREATE_PRESENT" | append_conftest "functions" ++ echo "#define NV_KMEM_CACHE_CREATE_ARGUMENT_COUNT 6" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/slab.h> ++ void conftest_kmem_cache_create(void) { ++ kmem_cache_create(NULL, 0, 0, 0L, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_KMEM_CACHE_CREATE_PRESENT" | append_conftest "functions" ++ echo "#define NV_KMEM_CACHE_CREATE_ARGUMENT_COUNT 5" | append_conftest "functions" ++ return ++ else ++ echo "#error kmem_cache_create() conftest failed!" | append_conftest "functions" ++ fi ++ ;; ++ ++ smp_call_function) ++ # ++ # Determine if the smp_call_function() function is ++ # present and how many arguments it takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/smp.h> ++ void conftest_smp_call_function(void) { ++ #ifdef CONFIG_SMP ++ smp_call_function(); ++ #endif ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#undef NV_SMP_CALL_FUNCTION_PRESENT" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/smp.h> ++ void conftest_smp_call_function(void) { ++ smp_call_function(NULL, NULL, 0, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_SMP_CALL_FUNCTION_PRESENT" | append_conftest "functions" ++ echo "#define NV_SMP_CALL_FUNCTION_ARGUMENT_COUNT 4" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/smp.h> ++ void conftest_smp_call_function(void) { ++ smp_call_function(NULL, NULL, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_SMP_CALL_FUNCTION_PRESENT" | append_conftest "functions" ++ echo "#define NV_SMP_CALL_FUNCTION_ARGUMENT_COUNT 3" | append_conftest "functions" ++ return ++ else ++ echo "#error smp_call_function() conftest failed!" | append_conftest "functions" ++ fi ++ ;; ++ ++ on_each_cpu) ++ # ++ # Determine if the on_each_cpu() function is present ++ # and how many arguments it takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/smp.h> ++ void conftest_on_each_cpu(void) { ++ #ifdef CONFIG_SMP ++ on_each_cpu(); ++ #endif ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#undef NV_ON_EACH_CPU_PRESENT" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/smp.h> ++ void conftest_on_each_cpu(void) { ++ on_each_cpu(NULL, NULL, 0, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ON_EACH_CPU_PRESENT" | append_conftest "functions" ++ echo "#define NV_ON_EACH_CPU_ARGUMENT_COUNT 4" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/smp.h> ++ void conftest_on_each_cpu(void) { ++ on_each_cpu(NULL, NULL, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ON_EACH_CPU_PRESENT" | append_conftest "functions" ++ echo "#define NV_ON_EACH_CPU_ARGUMENT_COUNT 3" | append_conftest "functions" ++ return ++ else ++ echo "#error on_each_cpu() conftest failed!" | append_conftest "functions" ++ fi ++ ;; ++ ++ register_cpu_notifier) ++ # ++ # Determine if register_cpu_notifier() is present ++ # ++ # register_cpu_notifier() was removed by the following commit ++ # 2016 Dec 25: b272f732f888d4cf43c943a40c9aaa836f9b7431 ++ # ++ CODE=" ++ #include <linux/cpu.h> ++ void conftest_register_cpu_notifier(void) { ++ register_cpu_notifier(); ++ }" > conftest$$.c ++ compile_check_conftest "$CODE" "NV_REGISTER_CPU_NOTIFIER_PRESENT" "" "functions" ++ ;; ++ ++ cpuhp_setup_state) ++ # ++ # Determine if cpuhp_setup_state() is present ++ # ++ # cpuhp_setup_state() was added by the following commit ++ # 2016 Feb 26: 5b7aa87e0482be768486e0c2277aa4122487eb9d ++ # ++ # It is used as a replacement for register_cpu_notifier ++ CODE=" ++ #include <linux/cpu.h> ++ void conftest_cpuhp_setup_state(void) { ++ cpuhp_setup_state(); ++ }" > conftest$$.c ++ compile_check_conftest "$CODE" "NV_CPUHP_SETUP_STATE_PRESENT" "" "functions" ++ ;; ++ ++ acpi_evaluate_integer) ++ # ++ # Determine if the acpi_evaluate_integer() function is ++ # present and the type of its 'data' argument. ++ # ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/acpi.h> ++ acpi_status acpi_evaluate_integer(acpi_handle h, acpi_string s, ++ struct acpi_object_list *l, unsigned long long *d) { ++ return AE_OK; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ACPI_EVALUATE_INTEGER_PRESENT" | append_conftest "functions" ++ echo "typedef unsigned long long nv_acpi_integer_t;" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/acpi.h> ++ acpi_status acpi_evaluate_integer(acpi_handle h, acpi_string s, ++ struct acpi_object_list *l, unsigned long *d) { ++ return AE_OK; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ACPI_EVALUATE_INTEGER_PRESENT" | append_conftest "functions" ++ echo "typedef unsigned long nv_acpi_integer_t;" | append_conftest "functions" ++ return ++ else ++ # ++ # We can't report a compile test failure here because ++ # this is a catch-all for both kernels that don't ++ # have acpi_evaluate_integer() and kernels that have ++ # broken header files that make it impossible to ++ # tell if the function is present. ++ # ++ echo "#undef NV_ACPI_EVALUATE_INTEGER_PRESENT" | append_conftest "functions" ++ echo "typedef unsigned long nv_acpi_integer_t;" | append_conftest "functions" ++ fi ++ ;; ++ ++ acpi_walk_namespace) ++ # ++ # Determine if the acpi_walk_namespace() function is present ++ # and how many arguments it takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/acpi.h> ++ void conftest_acpi_walk_namespace(void) { ++ acpi_walk_namespace(); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#undef NV_ACPI_WALK_NAMESPACE_PRESENT" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/acpi.h> ++ void conftest_acpi_walk_namespace(void) { ++ acpi_walk_namespace(0, NULL, 0, NULL, NULL, NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ACPI_WALK_NAMESPACE_PRESENT" | append_conftest "functions" ++ echo "#define NV_ACPI_WALK_NAMESPACE_ARGUMENT_COUNT 7" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/acpi.h> ++ void conftest_acpi_walk_namespace(void) { ++ acpi_walk_namespace(0, NULL, 0, NULL, NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_ACPI_WALK_NAMESPACE_PRESENT" | append_conftest "functions" ++ echo "#define NV_ACPI_WALK_NAMESPACE_ARGUMENT_COUNT 6" | append_conftest "functions" ++ return ++ else ++ echo "#error acpi_walk_namespace() conftest failed!" | append_conftest "functions" ++ fi ++ ;; ++ ++ ioremap_cache) ++ # ++ # Determine if the ioremap_cache() function is present. ++ # ++ CODE=" ++ #include <asm/io.h> ++ void conftest_ioremap_cache(void) { ++ ioremap_cache(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_IOREMAP_CACHE_PRESENT" "" "functions" ++ ;; ++ ++ ioremap_nocache) ++ # ++ # Determine if the ioremap_nocache() function is present. ++ # ++ CODE=" ++ #include <asm/io.h> ++ void conftest_ioremap_nocache(void) { ++ ioremap_nocache(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_IOREMAP_NOCACHE_PRESENT" "" "functions" ++ ;; ++ ++ ioremap_wc) ++ # ++ # Determine if the ioremap_wc() function is present. ++ # ++ CODE=" ++ #include <asm/io.h> ++ void conftest_ioremap_wc(void) { ++ ioremap_wc(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_IOREMAP_WC_PRESENT" "" "functions" ++ ;; ++ ++ proc_dir_entry) ++ # ++ # Determine if the 'proc_dir_entry' structure has ++ # an 'owner' member. ++ # ++ CODE=" ++ #include <linux/proc_fs.h> ++ int conftest_proc_dir_entry(void) { ++ return offsetof(struct proc_dir_entry, owner); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PROC_DIR_ENTRY_HAS_OWNER" "" "types" ++ ;; ++ ++ INIT_WORK) ++ # ++ # Determine how many arguments the INIT_WORK() macro ++ # takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/workqueue.h> ++ void conftest_INIT_WORK(void) { ++ INIT_WORK(); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_INIT_WORK_PRESENT" | append_conftest "macros" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/workqueue.h> ++ void conftest_INIT_WORK(void) { ++ INIT_WORK((struct work_struct *)NULL, NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_INIT_WORK_PRESENT" | append_conftest "macros" ++ echo "#define NV_INIT_WORK_ARGUMENT_COUNT 3" | append_conftest "macros" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/workqueue.h> ++ void conftest_INIT_WORK(void) { ++ INIT_WORK((struct work_struct *)NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_INIT_WORK_PRESENT" | append_conftest "macros" ++ echo "#define NV_INIT_WORK_ARGUMENT_COUNT 2" | append_conftest "macros" ++ rm -f conftest$$.o ++ return ++ else ++ echo "#error INIT_WORK() conftest failed!" | append_conftest "macros" ++ return ++ fi ++ ;; ++ ++ dma_mapping_error) ++ # ++ # Determine how many arguments dma_mapping_error() ++ # takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/dma-mapping.h> ++ int conftest_dma_mapping_error(void) { ++ return dma_mapping_error(NULL, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT 2" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/dma-mapping.h> ++ int conftest_dma_mapping_error(void) { ++ return dma_mapping_error(0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT 1" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ else ++ echo "#error dma_mapping_error() conftest failed!" | append_conftest "functions" ++ return ++ fi ++ ;; ++ ++ scatterlist) ++ # ++ # Determine if the 'scatterlist' structure has ++ # a 'page_link' member. ++ # ++ CODE=" ++ #include <linux/types.h> ++ #include <linux/scatterlist.h> ++ int conftest_scatterlist(void) { ++ return offsetof(struct scatterlist, page_link); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SCATTERLIST_HAS_PAGE_LINK" "" "types" ++ ;; ++ ++ pci_domain_nr) ++ # ++ # Determine if the pci_domain_nr() function is present. ++ # ++ CODE=" ++ #include <linux/types.h> ++ #include <linux/pci.h> ++ int conftest_pci_domain_nr(struct pci_dev *dev) { ++ return pci_domain_nr(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_DOMAIN_NR_PRESENT" "" "functions" ++ ;; ++ ++ file_operations) ++ # ++ # Determine if the 'file_operations' structure has ++ # 'ioctl', 'unlocked_ioctl' and 'compat_ioctl' fields. ++ # ++ CODE=" ++ #include <linux/fs.h> ++ int conftest_file_operations(void) { ++ return offsetof(struct file_operations, ioctl); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FILE_OPERATIONS_HAS_IOCTL" "" "types" ++ ++ CODE=" ++ #include <linux/fs.h> ++ int conftest_file_operations(void) { ++ return offsetof(struct file_operations, unlocked_ioctl); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FILE_OPERATIONS_HAS_UNLOCKED_IOCTL" "" "types" ++ ++ CODE=" ++ #include <linux/fs.h> ++ int conftest_file_operations(void) { ++ return offsetof(struct file_operations, compat_ioctl); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL" "" "types" ++ ;; ++ ++ sg_table) ++ # ++ # Determine if the struct sg_table type is present. ++ # ++ CODE=" ++ #include <linux/scatterlist.h> ++ struct sg_table conftest_sg_table; ++ " ++ ++ compile_check_conftest "$CODE" "NV_SG_TABLE_PRESENT" "" "types" ++ ;; ++ ++ sg_alloc_table) ++ # ++ # Determine if include/linux/scatterlist.h exists and which table ++ # allocation functions are present if so. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/scatterlist.h> ++ void conftest_sg_alloc_table(void) { ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ ! -f conftest$$.o ]; then ++ echo "#undef NV_SG_ALLOC_TABLE_PRESENT" | append_conftest "functions" ++ echo "#undef NV_SG_ALLOC_TABLE_FROM_PAGES_PRESENT" | append_conftest "functions" ++ return ++ fi ++ ++ rm -f conftest$$.o ++ ++ CODE=" ++ #include <linux/scatterlist.h> ++ void conftest_sg_alloc_table(void) { ++ sg_alloc_table(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SG_ALLOC_TABLE_PRESENT" "" "functions" ++ ++ CODE=" ++ #include <linux/scatterlist.h> ++ void conftest_sg_alloc_table_from_pages(void) { ++ sg_alloc_table_from_pages(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SG_ALLOC_TABLE_FROM_PAGES_PRESENT" "" "functions" ++ ;; ++ ++ efi_enabled) ++ # ++ # Determine if the efi_enabled symbol is present, or if ++ # the efi_enabled() function is present and how many ++ # arguments it takes. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_LINUX_EFI_H_PRESENT) ++ #include <linux/efi.h> ++ #endif ++ int conftest_efi_enabled(void) { ++ return efi_enabled(); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_EFI_ENABLED_PRESENT" | append_conftest "symbols" ++ echo "#undef NV_EFI_ENABLED_PRESENT" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_LINUX_EFI_H_PRESENT) ++ #include <linux/efi.h> ++ #endif ++ int conftest_efi_enabled(void) { ++ return efi_enabled(0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_EFI_ENABLED_PRESENT" | append_conftest "functions" ++ echo "#define NV_EFI_ENABLED_ARGUMENT_COUNT 1" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ else ++ echo "#define NV_EFI_ENABLED_PRESENT" | append_conftest "symbols" ++ return ++ fi ++ ;; ++ ++ dom0_kernel_present) ++ # ++ # Add config parameter if running on DOM0. ++ # ++ if [ -n "$VGX_BUILD" ]; then ++ echo "#define NV_DOM0_KERNEL_PRESENT" | append_conftest "generic" ++ else ++ echo "#undef NV_DOM0_KERNEL_PRESENT" | append_conftest "generic" ++ fi ++ return ++ ;; ++ ++ nvidia_vgpu_kvm_build) ++ # ++ # Add config parameter if running on KVM host. ++ # ++ if [ -n "$VGX_KVM_BUILD" ]; then ++ echo "#define NV_VGPU_KVM_BUILD" | append_conftest "generic" ++ else ++ echo "#undef NV_VGPU_KVM_BUILD" | append_conftest "generic" ++ fi ++ return ++ ;; ++ ++ vfio_register_notifier) ++ # ++ # Check number of arguments required. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/vfio.h> ++ int conftest_vfio_register_notifier(void) { ++ return vfio_register_notifier((struct device *) NULL, (struct notifier_block *) NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_VFIO_NOTIFIER_ARGUMENT_COUNT 2" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ else ++ echo "#define NV_VFIO_NOTIFIER_ARGUMENT_COUNT 4" | append_conftest "functions" ++ return ++ fi ++ ;; ++ ++ vfio_info_add_capability_has_cap_type_id_arg) ++ # ++ # Check if vfio_info_add_capability() has cap_type_id field. ++ # cap_type_id field was removed in commit: ++ # 2017-12-12 dda01f787df9f9e46f1c0bf8aa11f246e300750d ++ # ++ CODE=" ++ #include <linux/vfio.h> ++ int vfio_info_add_capability(struct vfio_info_cap *caps, ++ int cap_type_id, ++ void *cap_type) { ++ return 0; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VFIO_INFO_ADD_CAPABILITY_HAS_CAP_TYPE_ID_ARGS" "" "types" ++ ;; ++ ++ nvidia_grid_build) ++ if [ -n "$GRID_BUILD" ]; then ++ echo "#define NV_GRID_BUILD" | append_conftest "generic" ++ else ++ echo "#undef NV_GRID_BUILD" | append_conftest "generic" ++ fi ++ return ++ ;; ++ ++ vm_fault_present) ++ # ++ # Determine if the 'vm_fault' structure is present. The earlier ++ # name for this struct was fault_data, and it was renamed to ++ # vm_fault by: ++ # ++ # 2007-07-19 d0217ac04ca6591841e5665f518e38064f4e65bd ++ # ++ CODE=" ++ #include <linux/mm.h> ++ int conftest_vm_fault_present(void) { ++ return offsetof(struct vm_fault, flags); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VM_FAULT_PRESENT" "" "types" ++ ;; ++ ++ vm_fault_has_address) ++ # ++ # Determine if the 'vm_fault' structure has an 'address', or a ++ # 'virtual_address' field. The .virtual_address field was ++ # effectively renamed to .address, by these two commits: ++ # ++ # struct vm_fault: .address was added by: ++ # 2016-12-14 82b0f8c39a3869b6fd2a10e180a862248736ec6f ++ # ++ # struct vm_fault: .virtual_address was removed by: ++ # 2016-12-14 1a29d85eb0f19b7d8271923d8917d7b4f5540b3e ++ # ++ CODE=" ++ #include <linux/mm.h> ++ int conftest_vm_fault_has_address(void) { ++ return offsetof(struct vm_fault, address); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VM_FAULT_HAS_ADDRESS" "" "types" ++ ;; ++ ++ kmem_cache_has_kobj_remove_work) ++ # ++ # Determine if the 'kmem_cache' structure has 'kobj_remove_work'. ++ # ++ # 'kobj_remove_work' was added by commit 3b7b314053d02 ("slub: make ++ # sysfs file removal asynchronous") in v4.12 (2017-06-23). This ++ # commit introduced a race between kmem_cache destroy and create ++ # which we need to workaround in our driver (see nvbug: 2543505). ++ # Also see comment for sysfs_slab_unlink conftest. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ #include <linux/slab.h> ++ #include <linux/slub_def.h> ++ int conftest_kmem_cache_has_kobj_remove_work(void) { ++ return offsetof(struct kmem_cache, kobj_remove_work); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_KMEM_CACHE_HAS_KOBJ_REMOVE_WORK" "" "types" ++ ;; ++ ++ mdev_uuid) ++ # ++ # Determine if mdev_uuid() function is present or not ++ # ++ CODE=" ++ #include <linux/pci.h> ++ #include <linux/mdev.h> ++ void conftest_mdev_uuid() { ++ mdev_uuid(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_MDEV_UUID_PRESENT" "" "functions" ++ ;; ++ ++ mdev_dev) ++ # ++ # Determine if mdev_dev() function is present or not ++ # ++ CODE=" ++ #include <linux/pci.h> ++ #include <linux/mdev.h> ++ void conftest_mdev_dev() { ++ mdev_dev(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_MDEV_DEV_PRESENT" "" "functions" ++ ;; ++ ++ mdev_parent) ++ # ++ # Determine if the struct mdev_parent type is present. ++ # ++ CODE=" ++ #include <linux/pci.h> ++ #include <linux/mdev.h> ++ struct mdev_parent_ops conftest_mdev_parent; ++ " ++ ++ compile_check_conftest "$CODE" "NV_MDEV_PARENT_OPS_STRUCT_PRESENT" "" "types" ++ ;; ++ ++ mdev_parent_dev) ++ # ++ # Determine if mdev_parent_dev() function is present or not ++ # ++ CODE=" ++ #include <linux/pci.h> ++ #include <linux/mdev.h> ++ void conftest_mdev_parent_dev() { ++ mdev_parent_dev(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_MDEV_PARENT_DEV_PRESENT" "" "functions" ++ ;; ++ ++ mdev_from_dev) ++ # ++ # Determine if mdev_from_dev() function is present or not. ++ # ++ # Added: 2016-12-30 99e3123e3d72616a829dad6d25aa005ef1ef9b13 ++ # ++ CODE=" ++ #include <linux/pci.h> ++ #include <linux/mdev.h> ++ void conftest_mdev_from_dev() { ++ mdev_from_dev(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_MDEV_FROM_DEV_PRESENT" "" "functions" ++ ;; ++ ++ drm_available) ++ # ++ # Determine if the DRM subsystem is usable ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ ++ #if !defined(CONFIG_DRM) && !defined(CONFIG_DRM_MODULE) ++ #error DRM not enabled ++ #endif ++ ++ void conftest_drm_available(void) { ++ struct drm_driver drv; ++ ++ /* 2013-10-02 1bb72532ac260a2d3982b40bdd4c936d779d0d16 */ ++ (void)drm_dev_alloc; ++ ++ /* 2013-10-02 c22f0ace1926da399d9a16dfaf09174c1b03594c */ ++ (void)drm_dev_register; ++ ++ /* 2013-10-02 c3a49737ef7db0bdd4fcf6cf0b7140a883e32b2a */ ++ (void)drm_dev_unregister; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_AVAILABLE" "" "generic" ++ ;; ++ ++ drm_dev_unref) ++ # ++ # Determine if drm_dev_unref() is present. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ void conftest_drm_dev_unref(void) { ++ /* ++ * drm_dev_free() was added in: ++ * 2013-10-02 0dc8fe5985e01f238e7dc64ff1733cc0291811e8 ++ * drm_dev_free() was renamed to drm_dev_unref() in: ++ * 2014-01-29 099d1c290e2ebc3b798961a6c177c3aef5f0b789 ++ */ ++ drm_dev_unref(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DEV_UNREF_PRESENT" "" "functions" ++ ;; ++ ++ proc_create_data) ++ # ++ # Determine if the proc_create_data() function is present. ++ # ++ CODE=" ++ #include <linux/proc_fs.h> ++ void conftest_proc_create_data(void) { ++ proc_create_data(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PROC_CREATE_DATA_PRESENT" "" "functions" ++ ;; ++ ++ ++ pde_data) ++ # ++ # Determine if the pde_data() function is present. ++ # ++ # The commit c28198889c15 removed the function ++ # 'PDE_DATA()', and replaced it with 'pde_data()' ++ # ("proc: remove PDE_DATA() completely") in v5.17-rc1. ++ # ++ CODE=" ++ #include <linux/proc_fs.h> ++ void conftest_pde_data(void) { ++ pde_data(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PDE_DATA_PRESENT" "" "functions" ++ ;; ++ ++ PDE_DATA) ++ # ++ # Determine if the PDE_DATA() function is present. ++ # ++ CODE=" ++ #include <linux/proc_fs.h> ++ void conftest_PDE_DATA(void) { ++ PDE_DATA(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PDE_DATA_UPPER_CASE_PRESENT" "" "functions" ++ ;; ++ ++ get_num_physpages) ++ # ++ # Determine if the get_num_physpages() function is ++ # present. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_get_num_physpages(void) { ++ get_num_physpages(NULL); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_GET_NUM_PHYSPAGES_PRESENT" "" "functions" ++ ;; ++ ++ proc_remove) ++ # ++ # Determine if the proc_remove() function is present. ++ # ++ CODE=" ++ #include <linux/proc_fs.h> ++ void conftest_proc_remove(void) { ++ proc_remove(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PROC_REMOVE_PRESENT" "" "functions" ++ ;; ++ ++ vm_operations_struct) ++ # ++ # Determine if the 'vm_operations_struct' structure has ++ # 'fault' and 'access' fields. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ int conftest_vm_operations_struct(void) { ++ return offsetof(struct vm_operations_struct, fault); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VM_OPERATIONS_STRUCT_HAS_FAULT" "" "types" ++ ++ CODE=" ++ #include <linux/mm.h> ++ int conftest_vm_operations_struct(void) { ++ return offsetof(struct vm_operations_struct, access); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VM_OPERATIONS_STRUCT_HAS_ACCESS" "" "types" ++ ;; ++ ++ fault_flags) ++ # Determine if the FAULT_FLAG_WRITE is defined ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_fault_flags(void) { ++ int flag = FAULT_FLAG_WRITE; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FAULT_FLAG_PRESENT" "" "types" ++ ;; ++ ++ atomic_long_type) ++ # Determine if atomic_long_t and associated functions are defined ++ # Added in 2.6.16 2006-01-06 d3cb487149bd706aa6aeb02042332a450978dc1c ++ CODE=" ++ #include <asm/atomic.h> ++ void conftest_atomic_long(void) { ++ atomic_long_t data; ++ atomic_long_read(&data); ++ atomic_long_set(&data, 0); ++ atomic_long_inc(&data); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ATOMIC_LONG_PRESENT" "" "types" ++ ;; ++ ++ atomic64_type) ++ # Determine if atomic64_t and associated functions are defined ++ CODE=" ++ #include <asm/atomic.h> ++ void conftest_atomic64(void) { ++ atomic64_t data; ++ atomic64_read(&data); ++ atomic64_set(&data, 0); ++ atomic64_inc(&data); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ATOMIC64_PRESENT" "" "types" ++ ;; ++ ++ task_struct) ++ # ++ # Determine if the 'task_struct' structure has ++ # a 'cred' field. ++ # ++ CODE=" ++ #include <linux/sched.h> ++ int conftest_task_struct(void) { ++ return offsetof(struct task_struct, cred); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_TASK_STRUCT_HAS_CRED" "" "types" ++ ;; ++ ++ backing_dev_info) ++ # ++ # Determine if the 'address_space' structure has ++ # a 'backing_dev_info' field. ++ # ++ CODE=" ++ #include <linux/fs.h> ++ int conftest_backing_dev_info(void) { ++ return offsetof(struct address_space, backing_dev_info); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ADDRESS_SPACE_HAS_BACKING_DEV_INFO" "" "types" ++ ;; ++ ++ address_space) ++ # ++ # Determine if the 'address_space' structure has ++ # a 'tree_lock' field of type rwlock_t. ++ # ++ CODE=" ++ #include <linux/fs.h> ++ int conftest_address_space(void) { ++ struct address_space as; ++ rwlock_init(&as.tree_lock); ++ return offsetof(struct address_space, tree_lock); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ADDRESS_SPACE_HAS_RWLOCK_TREE_LOCK" "" "types" ++ ;; ++ ++ address_space_init_once) ++ # ++ # Determine if address_space_init_once is present. ++ # ++ CODE=" ++ #include <linux/fs.h> ++ void conftest_address_space_init_once(void) { ++ address_space_init_once(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ADDRESS_SPACE_INIT_ONCE_PRESENT" "" "functions" ++ ;; ++ ++ kbasename) ++ # ++ # Determine if the kbasename() function is present. ++ # ++ CODE=" ++ #include <linux/string.h> ++ void conftest_kbasename(void) { ++ kbasename(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_KBASENAME_PRESENT" "" "functions" ++ ;; ++ ++ fatal_signal_pending) ++ # ++ # Determine if fatal_signal_pending is present. ++ # ++ CODE=" ++ #if defined(NV_LINUX_SCHED_SIGNAL_H_PRESENT) ++ #include <linux/sched/signal.h> ++ #else ++ #include <linux/sched.h> ++ #endif ++ void conftest_fatal_signal_pending(void) { ++ fatal_signal_pending(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FATAL_SIGNAL_PENDING_PRESENT" "" "functions" ++ ;; ++ ++ kuid_t) ++ # ++ # Determine if the 'kuid_t' type is present. ++ # ++ CODE=" ++ #include <linux/sched.h> ++ kuid_t conftest_kuid_t; ++ " ++ ++ compile_check_conftest "$CODE" "NV_KUID_T_PRESENT" "" "types" ++ ;; ++ ++ pm_vt_switch_required) ++ # ++ # Determine if the pm_vt_switch_required() function is present. ++ # ++ CODE=" ++ #include <linux/pm.h> ++ void conftest_pm_vt_switch_required(void) { ++ pm_vt_switch_required(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PM_VT_SWITCH_REQUIRED_PRESENT" "" "functions" ++ ;; ++ ++ list_cut_position) ++ # ++ # Determine if the list_cut_position() function is present. ++ # ++ CODE=" ++ #include <linux/list.h> ++ void conftest_list_cut_position(void) { ++ list_cut_position(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_LIST_CUT_POSITION_PRESENT" "" "functions" ++ ;; ++ ++ file_inode) ++ # ++ # Determine if the 'file' structure has ++ # a 'f_inode' field. ++ # ++ CODE=" ++ #include <linux/fs.h> ++ int conftest_file_inode(void) { ++ return offsetof(struct file, f_inode); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FILE_HAS_INODE" "" "types" ++ ;; ++ ++ xen_ioemu_inject_msi) ++ # ++ # Determine if the xen_ioemu_inject_msi() function is present. ++ # ++ CODE=" ++ #if defined(NV_XEN_IOEMU_H_PRESENT) ++ #include <linux/kernel.h> ++ #include <xen/interface/xen.h> ++ #include <xen/hvm.h> ++ #include <xen/ioemu.h> ++ #endif ++ void conftest_xen_ioemu_inject_msi(void) { ++ xen_ioemu_inject_msi(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_XEN_IOEMU_INJECT_MSI" "" "functions" ++ ;; ++ ++ phys_to_dma) ++ # ++ # Determine if the phys_to_dma function is present. ++ # ++ CODE=" ++ #include <linux/dma-mapping.h> ++ void conftest_phys_to_dma(void) { ++ phys_to_dma(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PHYS_TO_DMA_PRESENT" "" "functions" ++ ;; ++ ++ dma_ops) ++ # ++ # Determine if the 'dma_ops' structure is present. ++ # ++ CODE=" ++ #include <linux/dma-mapping.h> ++ void conftest_dma_ops(void) { ++ (void)dma_ops; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DMA_OPS_PRESENT" "" "symbols" ++ ;; ++ ++ swiotlb_dma_ops) ++ # ++ # Determine if the 'swiotlb_dma_ops' structure is present. ++ # It does not exist on all architectures. ++ # ++ CODE=" ++ #include <linux/dma-mapping.h> ++ void conftest_dma_ops(void) { ++ (void)swiotlb_dma_ops; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_SWIOTLB_DMA_OPS_PRESENT" "" "symbols" ++ ;; ++ ++ dma_map_ops) ++ # ++ # Determine if the 'struct dma_map_ops' type is present. ++ # ++ # Commit 0a0f0d8be76d ("dma-mapping: split <linux/dma-mapping.h>") ++ # in v5.10-rc1 (2020-09-22), moved 'struct dma_map_ops' ++ # type from <linux/dma-mapping.h> to <linux/dma-map-ops.h>. ++ # ++ CODE=" ++ #if defined(NV_LINUX_DMA_MAP_OPS_H_PRESENT) ++ #include <linux/dma-map-ops.h> ++ #else ++ #include <linux/dma-mapping.h> ++ #endif ++ void conftest_dma_map_ops(void) { ++ struct dma_map_ops ops; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DMA_MAP_OPS_PRESENT" "" "types" ++ ;; ++ ++ get_dma_ops) ++ # ++ # Determine if the get_dma_ops() function is present. ++ # ++ # Commit 0a0f0d8be76d ("dma-mapping: split <linux/dma-mapping.h>") ++ # in v5.10-rc1 (2020-09-22), moved get_dma_ops() function ++ # prototype from <linux/dma-mapping.h> to <linux/dma-map-ops.h>. ++ # ++ CODE=" ++ #if defined(NV_LINUX_DMA_MAP_OPS_H_PRESENT) ++ #include <linux/dma-map-ops.h> ++ #else ++ #include <linux/dma-mapping.h> ++ #endif ++ void conftest_get_dma_ops(void) { ++ get_dma_ops(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_GET_DMA_OPS_PRESENT" "" "functions" ++ ;; ++ ++ noncoherent_swiotlb_dma_ops) ++ # ++ # Determine if the 'noncoherent_swiotlb_dma_ops' symbol is present. ++ # ++ CODE=" ++ #include <linux/dma-mapping.h> ++ void conftest_noncoherent_swiotlb_dma_ops(void) { ++ (void)noncoherent_swiotlb_dma_ops; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_NONCOHERENT_SWIOTLB_DMA_OPS_PRESENT" "" "symbols" ++ ;; ++ ++ dma_map_resource) ++ # ++ # Determine if the dma_map_resource() function is present. ++ # ++ # dma_map_resource() was added by: ++ # 2016-08-10 6f3d87968f9c8b529bc81eff5a1f45e92553493d ++ # ++ CODE=" ++ #include <linux/dma-mapping.h> ++ void conftest_dma_map_resource(void) { ++ dma_map_resource(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DMA_MAP_RESOURCE_PRESENT" "" "functions" ++ ;; ++ ++ write_cr4) ++ # ++ # Determine if the write_cr4() function is present. ++ # ++ CODE=" ++ #include <asm/processor.h> ++ void conftest_write_cr4(void) { ++ write_cr4(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_WRITE_CR4_PRESENT" "" "functions" ++ ;; ++ ++ of_get_property) ++ # ++ # Determine if the of_get_property function is present. ++ # ++ CODE=" ++ #if defined(NV_LINUX_OF_H_PRESENT) ++ #include <linux/of.h> ++ #endif ++ void conftest_of_get_property() { ++ of_get_property(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_OF_GET_PROPERTY_PRESENT" "" "functions" ++ ;; ++ ++ of_find_node_by_phandle) ++ # ++ # Determine if the of_find_node_by_phandle function is present. ++ # ++ CODE=" ++ #if defined(NV_LINUX_OF_H_PRESENT) ++ #include <linux/of.h> ++ #endif ++ void conftest_of_find_node_by_phandle() { ++ of_find_node_by_phandle(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_OF_FIND_NODE_BY_PHANDLE_PRESENT" "" "functions" ++ ;; ++ ++ of_node_to_nid) ++ # ++ # Determine if of_node_to_nid is present ++ # ++ CODE=" ++ #include <linux/version.h> ++ #include <linux/utsname.h> ++ #if defined(NV_LINUX_OF_H_PRESENT) ++ #include <linux/of.h> ++ #endif ++ void conftest_of_node_to_nid() { ++ of_node_to_nid(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_OF_NODE_TO_NID_PRESENT" "" "functions" ++ ;; ++ ++ pnv_pci_get_npu_dev) ++ # ++ # Determine if the pnv_pci_get_npu_dev function is present. ++ # ++ CODE=" ++ #include <linux/pci.h> ++ void conftest_pnv_pci_get_npu_dev() { ++ pnv_pci_get_npu_dev(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PNV_PCI_GET_NPU_DEV_PRESENT" "" "functions" ++ ;; ++ ++ for_each_online_node) ++ # ++ # Determine if the for_each_online_node() function is present. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_for_each_online_node() { ++ for_each_online_node(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_FOR_EACH_ONLINE_NODE_PRESENT" "" "functions" ++ ;; ++ ++ node_end_pfn) ++ # ++ # Determine if the node_end_pfn() function is present. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_node_end_pfn() { ++ node_end_pfn(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_NODE_END_PFN_PRESENT" "" "functions" ++ ;; ++ ++ kernel_write) ++ # ++ # Determine if kernel_write function is present ++ # ++ CODE=" ++ #include <linux/fs.h> ++ void conftest_kernel_write() { ++ kernel_write(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_KERNEL_WRITE_PRESENT" "" "functions" ++ ;; ++ ++ strnstr) ++ # ++ # Determine if strnstr function is present ++ # ++ CODE=" ++ #include <linux/string.h> ++ void conftest_strnstr() { ++ strnstr(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_STRNSTR_PRESENT" "" "functions" ++ ;; ++ ++ iterate_dir) ++ # ++ # Determine if iterate_dir function is present ++ # ++ CODE=" ++ #include <linux/fs.h> ++ void conftest_iterate_dir() { ++ iterate_dir(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ITERATE_DIR_PRESENT" "" "functions" ++ ;; ++ kstrtoull) ++ # ++ # Determine if kstrtoull function is present ++ # ++ CODE=" ++ #include <linux/kernel.h> ++ void conftest_kstrtoull() { ++ kstrtoull(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_KSTRTOULL_PRESENT" "" "functions" ++ ;; ++ ++ drm_atomic_available) ++ # ++ # Determine if the DRM atomic modesetting subsystem is usable ++ # ++ # ("drm/atomic: Allow drivers to subclass drm_atomic_state, v3") in ++ # v4.2 (2018-05-18). ++ # ++ # Make conftest more robust by adding test for ++ # drm_atomic_set_mode_prop_for_crtc(), this function added by ++ # commit 955f3c334f0f ("drm/atomic: Add MODE_ID property") in v4.2 ++ # (2015-05-25). If the DRM atomic modesetting subsystem is ++ # back ported to Linux kernel older than v4.2, then commit ++ # 955f3c334f0f must be back ported in order to get NVIDIA-DRM KMS ++ # support. ++ # Commit 72fdb40c1a4b ("drm: extract drm_atomic_uapi.c") in v4.20 ++ # (2018-09-05), moved drm_atomic_set_mode_prop_for_crtc() function ++ # prototype from drm/drm_atomic.h to drm/drm_atomic_uapi.h. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ #include <drm/drm_atomic.h> ++ #if !defined(CONFIG_DRM) && !defined(CONFIG_DRM_MODULE) ++ #error DRM not enabled ++ #endif ++ void conftest_drm_atomic_modeset_available(void) { ++ size_t a; ++ ++ /* 2015-05-18 036ef5733ba433760a3512bb5f7a155946e2df05 */ ++ a = offsetof(struct drm_mode_config_funcs, atomic_state_alloc); ++ }" > conftest$$.c; ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ #include <drm/drm_atomic.h> ++ #if defined(NV_DRM_DRM_ATOMIC_UAPI_H_PRESENT) ++ #include <drm/drm_atomic_uapi.h> ++ #endif ++ void conftest_drm_atomic_set_mode_prop_for_crtc(void) { ++ drm_atomic_set_mode_prop_for_crtc(); ++ }" > conftest$$.c; ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#undef NV_DRM_ATOMIC_MODESET_AVAILABLE" | append_conftest "generic" ++ else ++ echo "#define NV_DRM_ATOMIC_MODESET_AVAILABLE" | append_conftest "generic" ++ fi ++ else ++ echo "#undef NV_DRM_ATOMIC_MODESET_AVAILABLE" | append_conftest "generic" ++ fi ++ ;; ++ ++ drm_bus_present) ++ # ++ # Determine if the 'struct drm_bus' type is present. ++ # ++ # added: 2010-12-15 8410ea3b95d105a5be5db501656f44bbb91197c1 ++ # removed: 2014-08-29 c5786fe5f1c50941dbe27fc8b4aa1afee46ae893 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ void conftest_drm_bus_present(void) { ++ struct drm_bus bus; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_BUS_PRESENT" "" "types" ++ ;; ++ ++ drm_bus_has_bus_type) ++ # ++ # Determine if the 'drm_bus' structure has a 'bus_type' field. ++ # ++ # added: 2010-12-15 8410ea3b95d105a5be5db501656f44bbb91197c1 ++ # removed: 2013-11-03 42b21049fc26513ca8e732f47559b1525b04a992 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ int conftest_drm_bus_has_bus_type(void) { ++ return offsetof(struct drm_bus, bus_type); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_BUS_HAS_BUS_TYPE" "" "types" ++ ;; ++ ++ drm_bus_has_get_irq) ++ # ++ # Determine if the 'drm_bus' structure has a 'get_irq' field. ++ # ++ # added: 2010-12-15 8410ea3b95d105a5be5db501656f44bbb91197c1 ++ # removed: 2013-11-03 b2a21aa25a39837d06eb24a7f0fef1733f9843eb ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ int conftest_drm_bus_has_get_irq(void) { ++ return offsetof(struct drm_bus, get_irq); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_BUS_HAS_GET_IRQ" "" "types" ++ ;; ++ ++ drm_bus_has_get_name) ++ # ++ # Determine if the 'drm_bus' structure has a 'get_name' field. ++ # ++ # added: 2010-12-15 8410ea3b95d105a5be5db501656f44bbb91197c1 ++ # removed: 2013-11-03 9de1b51f1fae6476155350a0670dc637c762e718 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ int conftest_drm_bus_has_get_name(void) { ++ return offsetof(struct drm_bus, get_name); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_BUS_HAS_GET_NAME" "" "types" ++ ;; ++ ++ drm_driver_has_device_list) ++ # ++ # Determine if the 'drm_driver' structure has a 'device_list' field. ++ # ++ # Renamed from device_list to legacy_device_list by commit ++ # b3f2333de8e8 ("drm: restrict the device list for shadow ++ # attached drivers") in v3.14 (2013-12-11) ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ ++ int conftest_drm_driver_has_device_list(void) { ++ return offsetof(struct drm_driver, device_list); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_HAS_DEVICE_LIST" "" "types" ++ ;; ++ ++ ++ drm_driver_has_legacy_dev_list) ++ # ++ # Determine if the 'drm_driver' structure has a 'legacy_dev_list' field. ++ # ++ # drm_driver::device_list was added by: ++ # 2008-11-28 e7f7ab45ebcb54fd5f814ea15ea079e079662f67 ++ # and then renamed to drm_driver::legacy_device_list by: ++ # 2013-12-11 b3f2333de8e81b089262b26d52272911523e605f ++ # ++ # The commit 57bb1ee60340 ("drm: Compile out legacy chunks from ++ # struct drm_device") compiles out the legacy chunks like ++ # drm_driver::legacy_dev_list. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ ++ int conftest_drm_driver_has_legacy_dev_list(void) { ++ return offsetof(struct drm_driver, legacy_dev_list); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_HAS_LEGACY_DEV_LIST" "" "types" ++ ;; ++ ++ jiffies_to_timespec) ++ # ++ # Determine if jiffies_to_timespec() is present ++ # ++ # removed by commit 751addac78b6 ++ # ("y2038: remove obsolete jiffies conversion functions") ++ # in v5.6-rc1 (2019-12-13). ++ CODE=" ++ #include <linux/jiffies.h> ++ void conftest_jiffies_to_timespec(void){ ++ jiffies_to_timespec(); ++ }" ++ compile_check_conftest "$CODE" "NV_JIFFIES_TO_TIMESPEC_PRESENT" "" "functions" ++ ;; ++ ++ drm_init_function_args) ++ # ++ # Determine if these functions: ++ # drm_universal_plane_init() ++ # drm_crtc_init_with_planes() ++ # drm_encoder_init() ++ # have a 'name' argument, which was added by these commits: ++ # drm_universal_plane_init: 2015-12-09 b0b3b7951114315d65398c27648705ca1c322faa ++ # drm_crtc_init_with_planes: 2015-12-09 f98828769c8838f526703ef180b3088a714af2f9 ++ # drm_encoder_init: 2015-12-09 13a3d91f17a5f7ed2acd275d18b6acfdb131fb15 ++ # ++ # Additionally determine whether drm_universal_plane_init() has a ++ # 'format_modifiers' argument, which was added by: ++ # 2017-07-23 e6fc3b68558e4c6d8d160b5daf2511b99afa8814 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_CRTC_H_PRESENT) ++ #include <drm/drm_crtc.h> ++ #endif ++ ++ int conftest_drm_crtc_init_with_planes_has_name_arg(void) { ++ return ++ drm_crtc_init_with_planes( ++ NULL, /* struct drm_device *dev */ ++ NULL, /* struct drm_crtc *crtc */ ++ NULL, /* struct drm_plane *primary */ ++ NULL, /* struct drm_plane *cursor */ ++ NULL, /* const struct drm_crtc_funcs *funcs */ ++ NULL); /* const char *name */ ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_CRTC_INIT_WITH_PLANES_HAS_NAME_ARG" "" "types" ++ ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_ENCODER_H_PRESENT) ++ #include <drm/drm_encoder.h> ++ #endif ++ ++ int conftest_drm_encoder_init_has_name_arg(void) { ++ return ++ drm_encoder_init( ++ NULL, /* struct drm_device *dev */ ++ NULL, /* struct drm_encoder *encoder */ ++ NULL, /* const struct drm_encoder_funcs *funcs */ ++ DRM_MODE_ENCODER_NONE, /* int encoder_type */ ++ NULL); /* const char *name */ ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ENCODER_INIT_HAS_NAME_ARG" "" "types" ++ ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_PLANE_H_PRESENT) ++ #include <drm/drm_plane.h> ++ #endif ++ ++ int conftest_drm_universal_plane_init_has_format_modifiers_arg(void) { ++ return ++ drm_universal_plane_init( ++ NULL, /* struct drm_device *dev */ ++ NULL, /* struct drm_plane *plane */ ++ 0, /* unsigned long possible_crtcs */ ++ NULL, /* const struct drm_plane_funcs *funcs */ ++ NULL, /* const uint32_t *formats */ ++ 0, /* unsigned int format_count */ ++ NULL, /* const uint64_t *format_modifiers */ ++ DRM_PLANE_TYPE_PRIMARY, ++ NULL); /* const char *name */ ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ ++ echo "#define NV_DRM_UNIVERSAL_PLANE_INIT_HAS_FORMAT_MODIFIERS_ARG" | append_conftest "types" ++ echo "#define NV_DRM_UNIVERSAL_PLANE_INIT_HAS_NAME_ARG" | append_conftest "types" ++ else ++ echo "#undef NV_DRM_UNIVERSAL_PLANE_INIT_HAS_FORMAT_MODIFIERS_ARG" | append_conftest "types" ++ ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_PLANE_H_PRESENT) ++ #include <drm/drm_plane.h> ++ #endif ++ ++ int conftest_drm_universal_plane_init_has_name_arg(void) { ++ return ++ drm_universal_plane_init( ++ NULL, /* struct drm_device *dev */ ++ NULL, /* struct drm_plane *plane */ ++ 0, /* unsigned long possible_crtcs */ ++ NULL, /* const struct drm_plane_funcs *funcs */ ++ NULL, /* const uint32_t *formats */ ++ 0, /* unsigned int format_count */ ++ DRM_PLANE_TYPE_PRIMARY, ++ NULL); /* const char *name */ ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ ++ echo "#define NV_DRM_UNIVERSAL_PLANE_INIT_HAS_NAME_ARG" | append_conftest "types" ++ else ++ echo "#undef NV_DRM_UNIVERSAL_PLANE_INIT_HAS_NAME_ARG" | append_conftest "types" ++ fi ++ fi ++ ++ ;; ++ ++ drm_mode_connector_list_update_has_merge_type_bits_arg) ++ # ++ # Detect if drm_mode_connector_list_update() has a ++ # 'merge_type_bits' second argument. This argument was ++ # remove by: ++ # 2015-12-03 6af3e6561243f167dabc03f732d27ff5365cd4a4 ++ # ++ CODE=" ++ #include <drm/drmP.h> ++ void conftest_drm_mode_connector_list_update_has_merge_type_bits_arg(void) { ++ drm_mode_connector_list_update( ++ NULL, /* struct drm_connector *connector */ ++ true); /* bool merge_type_bits */ ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_MODE_CONNECTOR_LIST_UPDATE_HAS_MERGE_TYPE_BITS_ARG" "" "types" ++ ;; ++ ++ vzalloc) ++ # ++ # Determine if the vzalloc function is present ++ # Added in 2.6.37 2010-10-26 e1ca7788dec6773b1a2bce51b7141948f2b8bccf ++ # ++ CODE=" ++ #include <linux/vmalloc.h> ++ void conftest_vzalloc() { ++ vzalloc(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VZALLOC_PRESENT" "" "functions" ++ ;; ++ ++ drm_driver_has_set_busid) ++ # ++ # Determine if the drm_driver structure has a 'set_busid' callback ++ # field. ++ # ++ # drm_driver::set_busid field were added by: ++ # 2014-08-29 915b4d11b8b9e7b84ba4a4645b6cc7fbc0c071cf ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ int conftest_drm_driver_has_set_busid(void) { ++ return offsetof(struct drm_driver, set_busid); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_HAS_SET_BUSID" "" "types" ++ ;; ++ ++ drm_driver_has_gem_prime_res_obj) ++ # ++ # Determine if the drm_driver structure has a 'gem_prime_res_obj' ++ # callback field. ++ # ++ # drm_driver::gem_prime_res_obj field was added by: ++ # 2014-07-01 3aac4502fd3f80dcf7e65dbf6edd8676893c1f46 ++ # ++ # Removed by commit 51c98747113e (drm/prime: Ditch ++ # gem_prime_res_obj hook) in v5.4. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ int conftest_drm_driver_has_gem_prime_res_obj(void) { ++ return offsetof(struct drm_driver, gem_prime_res_obj); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ" "" "types" ++ ;; ++ ++ drm_crtc_state_has_connectors_changed) ++ # ++ # Determine if the crtc_state has a 'connectors_changed' field. ++ # ++ # drm_crtc_state::connectors_changed was added by: ++ # 2015-07-21 fc596660dd4e83f7f84e3cd7b25dc5e8e83000ef ++ # ++ CODE=" ++ #include <drm/drm_crtc.h> ++ void conftest_drm_crtc_state_has_connectors_changed(void) { ++ struct drm_crtc_state foo; ++ (void)foo.connectors_changed; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_CRTC_STATE_HAS_CONNECTORS_CHANGED" "" "types" ++ ;; ++ ++ drm_reinit_primary_mode_group) ++ # ++ # Determine if the function drm_reinit_primary_mode_group() is ++ # present. ++ # ++ # drm_reinit_primary_mode_group was added by: ++ # 2014-06-05 2390cd11bfbe8d2b1b28c4e0f01fe7e122f7196d ++ # removed by commit: ++ # 2015-07-09 3fdefa399e4644399ce3e74e65a75122d52dba6a ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_CRTC_H_PRESENT) ++ #include <drm/drm_crtc.h> ++ #endif ++ void conftest_drm_reinit_primary_mode_group(void) { ++ drm_reinit_primary_mode_group(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_REINIT_PRIMARY_MODE_GROUP_PRESENT" "" "functions" ++ ;; ++ ++ wait_on_bit_lock_argument_count) ++ # ++ # Determine how many arguments wait_on_bit_lock takes. ++ # ++ # wait_on_bit_lock changed by ++ # 2014-07-07 743162013d40ca612b4cb53d3a200dff2d9ab26e ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/wait.h> ++ void conftest_wait_on_bit_lock(void) { ++ wait_on_bit_lock(NULL, 0, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_WAIT_ON_BIT_LOCK_ARGUMENT_COUNT 3" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/wait.h> ++ void conftest_wait_on_bit_lock(void) { ++ wait_on_bit_lock(NULL, 0, NULL, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_WAIT_ON_BIT_LOCK_ARGUMENT_COUNT 4" | append_conftest "functions" ++ return ++ fi ++ echo "#error wait_on_bit_lock() conftest failed!" | append_conftest "functions" ++ ;; ++ ++ bitmap_clear) ++ # ++ # Determine if the bitmap_clear function is present ++ # Added in 2.6.33 2009-12-15 c1a2a962a2ad103846e7950b4591471fabecece7 ++ # ++ CODE=" ++ #include <linux/bitmap.h> ++ void conftest_bitmap_clear() { ++ bitmap_clear(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_BITMAP_CLEAR_PRESENT" "" "functions" ++ ;; ++ ++ pci_stop_and_remove_bus_device) ++ # ++ # Determine if the pci_stop_and_remove_bus_device() function is present. ++ # Added in 3.4-rc1 2012-02-25 210647af897af8ef2d00828aa2a6b1b42206aae6 ++ # ++ CODE=" ++ #include <linux/types.h> ++ #include <linux/pci.h> ++ void conftest_pci_stop_and_remove_bus_device() { ++ pci_stop_and_remove_bus_device(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_STOP_AND_REMOVE_BUS_DEVICE_PRESENT" "" "functions" ++ ;; ++ ++ pci_remove_bus_device) ++ # ++ # Determine if the pci_remove_bus_device() function is present. ++ # Added before Linux-2.6.12-rc2 2005-04-16 ++ # ++ CODE=" ++ #include <linux/types.h> ++ #include <linux/pci.h> ++ void conftest_pci_remove_bus_device() { ++ pci_remove_bus_device(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PCI_REMOVE_BUS_DEVICE_PRESENT" "" "functions" ++ ;; ++ ++ drm_atomic_set_mode_for_crtc) ++ # ++ # Determine if the function drm_atomic_set_mode_for_crtc() is ++ # present. ++ # ++ # drm_atomic_set_mode_for_crtc() was added by: ++ # 2015-05-26 819364da20fd914aba2fd03e95ee0467286752f5 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_ATOMIC_H_PRESENT) ++ #include <drm/drm_atomic.h> ++ #endif ++ void conftest_drm_atomic_clean_old_fb(void) { ++ drm_atomic_set_mode_for_crtc(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_SET_MODE_FOR_CRTC" "" "functions" ++ ;; ++ ++ drm_atomic_clean_old_fb) ++ # ++ # Determine if the function drm_atomic_clean_old_fb() is ++ # present. ++ # ++ # drm_atomic_clean_old_fb() was added by: ++ # 2015-11-11 0f45c26fc302c02b0576db37d4849baa53a2bb41 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_ATOMIC_H_PRESENT) ++ #include <drm/drm_atomic.h> ++ #endif ++ void conftest_drm_atomic_clean_old_fb(void) { ++ drm_atomic_clean_old_fb(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_CLEAN_OLD_FB" "" "functions" ++ ;; ++ ++ drm_helper_mode_fill_fb_struct | drm_helper_mode_fill_fb_struct_has_const_mode_cmd_arg) ++ # ++ # Determine if the drm_helper_mode_fill_fb_struct function takes ++ # 'dev' argument. ++ # ++ # The drm_helper_mode_fill_fb_struct() has been updated to ++ # take 'dev' parameter by: ++ # 2016-12-14 a3f913ca98925d7e5bae725e9b2b38408215a695 ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <drm/drm_crtc_helper.h> ++ void drm_helper_mode_fill_fb_struct(struct drm_device *dev, ++ struct drm_framebuffer *fb, ++ const struct drm_mode_fb_cmd2 *mode_cmd) ++ { ++ return; ++ }" > conftest$$.c; ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DRM_HELPER_MODE_FILL_FB_STRUCT_HAS_DEV_ARG" | append_conftest "function" ++ echo "#define NV_DRM_HELPER_MODE_FILL_FB_STRUCT_HAS_CONST_MODE_CMD_ARG" | append_conftest "function" ++ rm -f conftest$$.o ++ else ++ echo "#undef NV_DRM_HELPER_MODE_FILL_FB_STRUCT_HAS_DEV_ARG" | append_conftest "function" ++ ++ # ++ # Determine if the drm_mode_fb_cmd2 pointer argument is const in ++ # drm_mode_config_funcs::fb_create and drm_helper_mode_fill_fb_struct(). ++ # ++ # The drm_mode_fb_cmd2 pointer through this call chain was made const by: ++ # 2015-11-11 1eb83451ba55d7a8c82b76b1591894ff2d4a95f2 ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <drm/drm_crtc_helper.h> ++ void drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb, ++ const struct drm_mode_fb_cmd2 *mode_cmd) ++ { ++ return; ++ }" > conftest$$.c; ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DRM_HELPER_MODE_FILL_FB_STRUCT_HAS_CONST_MODE_CMD_ARG" | append_conftest "function" ++ rm -f conftest$$.o ++ else ++ echo "#undef NV_DRM_HELPER_MODE_FILL_FB_STRUCT_HAS_CONST_MODE_CMD_ARG" | append_conftest "function" ++ fi ++ fi ++ ;; ++ ++ mm_context_t) ++ # ++ # Determine if the 'mm_context_t' data type is present ++ # and if it has an 'id' member. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ int conftest_mm_context_t(void) { ++ return offsetof(mm_context_t, id); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_MM_CONTEXT_T_HAS_ID" | append_conftest "types" ++ rm -f conftest$$.o ++ return ++ else ++ echo "#undef NV_MM_CONTEXT_T_HAS_ID" | append_conftest "types" ++ return ++ fi ++ ;; ++ get_user_pages) ++ # ++ # Conftest for get_user_pages() ++ # ++ # Use long type for get_user_pages and unsigned long for nr_pages ++ # 2013 Feb 22: 28a35716d317980ae9bc2ff2f84c33a3cda9e884 ++ # ++ # Removed struct task_struct *tsk & struct mm_struct *mm from get_user_pages. ++ # 2016 Feb 12: cde70140fed8429acf7a14e2e2cbd3e329036653 ++ # ++ # Replaced get_user_pages6 with get_user_pages. ++ # 2016 April 4: c12d2da56d0e07d230968ee2305aaa86b93a6832 ++ # ++ # Replaced write and force parameters with gup_flags. ++ # 2016 Oct 12: 768ae309a96103ed02eb1e111e838c87854d8b51 ++ # ++ # linux-4.4.168 cherry-picked commit 768ae309a961 without ++ # c12d2da56d0e which is covered in Conftest #3. ++ # ++ # Conftest #1: Check if get_user_pages accepts 6 arguments. ++ # Return if true. ++ # Fall through to conftest #2 on failure. ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages(unsigned long start, ++ unsigned long nr_pages, ++ int write, ++ int force, ++ struct page **pages, ++ struct vm_area_struct **vmas) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ # Conftest #2: Check if get_user_pages has gup_flags instead of ++ # write and force parameters. And that gup doesn't accept a ++ # task_struct and mm_struct as its first arguments. ++ # Return if available. ++ # Fall through to conftest #3 on failure. ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages(unsigned long start, ++ unsigned long nr_pages, ++ unsigned int gup_flags, ++ struct page **pages, ++ struct vm_area_struct **vmas) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ # Conftest #3: Check if get_user_pages has gup_flags instead of ++ # write and force parameters AND that gup has task_struct and ++ # mm_struct as its first arguments. ++ # Return if available. ++ # Fall through to default case if absent. ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages(struct task_struct *tsk, ++ struct mm_struct *mm, ++ unsigned long start, ++ unsigned long nr_pages, ++ unsigned int gup_flags, ++ struct page **pages, ++ struct vm_area_struct **vmas) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#define NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "#define NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#define NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" ++ ++ return ++ ;; ++ ++ get_user_pages_remote) ++ # ++ # Determine if the function get_user_pages_remote() is ++ # present and has write/force/locked/tsk parameters. ++ # ++ # get_user_pages_remote() was added by: ++ # 2016 Feb 12: 1e9877902dc7e11d2be038371c6fbf2dfcd469d7 ++ # ++ # get_user_pages[_remote]() write/force parameters ++ # replaced with gup_flags: ++ # 2016 Oct 12: 768ae309a96103ed02eb1e111e838c87854d8b51 ++ # 2016 Oct 12: 9beae1ea89305a9667ceaab6d0bf46a045ad71e7 ++ # ++ # get_user_pages_remote() added 'locked' parameter ++ # 2016 Dec 14:5b56d49fc31dbb0487e14ead790fc81ca9fb2c99 ++ # ++ # get_user_pages_remote() removed 'tsk' parameter by ++ # commit 64019a2e467a ("mm/gup: remove task_struct pointer for ++ # all gup code") in v5.9-rc1 (2020-08-11). ++ # ++ # conftest #1: check if get_user_pages_remote() is available ++ # return if not available. ++ # Fall through to conftest #2 if it is present ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ void conftest_get_user_pages_remote(void) { ++ get_user_pages_remote(); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_GET_USER_PAGES_REMOTE_PRESENT" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_TSK_ARG" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ # conftest #2: check if get_user_pages_remote() has write and ++ # force arguments. Return if these arguments are present ++ # Fall through to conftest #3 if these args are absent. ++ echo "#define NV_GET_USER_PAGES_REMOTE_PRESENT" | append_conftest "functions" ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages_remote(struct task_struct *tsk, ++ struct mm_struct *mm, ++ unsigned long start, ++ unsigned long nr_pages, ++ int write, ++ int force, ++ struct page **pages, ++ struct vm_area_struct **vmas) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_GET_USER_PAGES_REMOTE_HAS_TSK_ARG" | append_conftest "functions" ++ echo "#define NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ ++ # ++ # conftest #3: check if get_user_pages_remote() has locked argument ++ # Return if these arguments are present. Fall through to conftest #4 ++ # if these args are absent. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages_remote(struct task_struct *tsk, ++ struct mm_struct *mm, ++ unsigned long start, ++ unsigned long nr_pages, ++ unsigned int gup_flags, ++ struct page **pages, ++ struct vm_area_struct **vmas, ++ int *locked) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_GET_USER_PAGES_REMOTE_HAS_TSK_ARG" | append_conftest "functions" ++ echo "#define NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ # ++ # conftest #4: check if get_user_pages_remote() does not take ++ # tsk argument. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages_remote(struct mm_struct *mm, ++ unsigned long start, ++ unsigned long nr_pages, ++ unsigned int gup_flags, ++ struct page **pages, ++ struct vm_area_struct **vmas, ++ int *locked) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_TSK_ARG" | append_conftest "functions" ++ echo "#define NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG" | append_conftest "functions" ++ rm -f conftest$$.o ++ else ++ ++ echo "#define NV_GET_USER_PAGES_REMOTE_HAS_TSK_ARG" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG" | append_conftest "functions" ++ fi ++ ;; ++ ++ usleep_range) ++ # ++ # Determine if the function usleep_range() is present. ++ # ++ # usleep_range() was added by: ++ # 2010 Aug 4 : 5e7f5a178bba45c5aca3448fddecabd4e28f1f6b ++ # ++ CODE=" ++ #include <linux/delay.h> ++ void conftest_usleep_range(void) { ++ usleep_range(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_USLEEP_RANGE_PRESENT" "" "functions" ++ ;; ++ ++ radix_tree_empty) ++ # ++ # Determine if the function radix_tree_empty() is present. ++ # ++ # radix_tree_empty() was added by: ++ # 2016 May 21 : e9256efcc8e390fa4fcf796a0c0b47d642d77d32 ++ # ++ CODE=" ++ #include <linux/radix-tree.h> ++ int conftest_radix_tree_empty(void) { ++ radix_tree_empty(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_RADIX_TREE_EMPTY_PRESENT" "" "functions" ++ ;; ++ ++ drm_gem_object_lookup) ++ # ++ # Determine the number of arguments of drm_gem_object_lookup(). ++ # ++ # drm_gem_object_lookup() was originally added to the kernel by: ++ # 2008-07-30 : 673a394b1e3b69be886ff24abfd6df97c52e8d08 ++ # ++ # First argument of type drm_device has been removed by: ++ # 2016-05-09 : a8ad0bd84f986072314595d05444719fdf29e412 ++ # ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ #if defined(NV_DRM_DRM_GEM_H_PRESENT) ++ #include <drm/drm_gem.h> ++ #endif ++ void conftest_drm_gem_object_lookup(void) { ++ drm_gem_object_lookup(NULL, NULL, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DRM_GEM_OBJECT_LOOKUP_PRESENT" | append_conftest "functions" ++ echo "#define NV_DRM_GEM_OBJECT_LOOKUP_ARGUMENT_COUNT 3" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ #if defined(NV_DRM_DRM_GEM_H_PRESENT) ++ #include <drm/drm_gem.h> ++ #endif ++ void conftest_drm_gem_object_lookup(void) { ++ drm_gem_object_lookup(NULL, 0); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DRM_GEM_OBJECT_LOOKUP_PRESENT" | append_conftest "functions" ++ echo "#define NV_DRM_GEM_OBJECT_LOOKUP_ARGUMENT_COUNT 2" | append_conftest "functions" ++ rm -f conftest$$.o ++ else ++ echo "#undef NV_DRM_GEM_OBJECT_LOOKUP_PRESENT" | append_conftest "functions" ++ echo "#undef NV_DRM_GEM_OBJECT_LOOKUP_ARGUMENT_COUNT" | append_conftest "functions" ++ fi ++ ;; ++ ++ drm_master_drop_has_from_release_arg) ++ # ++ # Determine if drm_driver::master_drop() has 'from_release' argument. ++ # ++ # Last argument 'bool from_release' has been removed by: ++ # 2016-06-21 : d6ed682eba54915ea56315bc2e5a33fca5922997 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ void conftest_drm_master_drop_has_from_release_arg(struct drm_driver *drv) { ++ drv->master_drop(NULL, NULL, false); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_MASTER_DROP_HAS_FROM_RELEASE_ARG" "" "types" ++ ;; ++ ++ drm_mode_config_funcs_has_atomic_state_alloc) ++ # ++ # Determine if the 'drm_mode_config_funcs' structure has ++ # an 'atomic_state_alloc' field. ++ # ++ # added: 2015-05-18 036ef5733ba433760a3512bb5f7a155946e2df05 ++ # ++ CODE=" ++ #include <drm/drm_crtc.h> ++ int conftest_drm_mode_config_funcs_has_atomic_state_alloc(void) { ++ return offsetof(struct drm_mode_config_funcs, atomic_state_alloc); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_MODE_CONFIG_FUNCS_HAS_ATOMIC_STATE_ALLOC" "" "types" ++ ;; ++ ++ drm_atomic_modeset_nonblocking_commit_available) ++ # ++ # Determine if nonblocking commit support avaiable in the DRM atomic ++ # modesetting subsystem. ++ # ++ # added: 2016-05-08 9f2a7950e77abf00a2a87f3b4cbefa36e9b6009b ++ # ++ CODE=" ++ #include <drm/drm_crtc.h> ++ int conftest_drm_atomic_modeset_nonblocking_commit_available(void) { ++ return offsetof(struct drm_mode_config, helper_private); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_MODESET_NONBLOCKING_COMMIT_AVAILABLE" "" "generic" ++ ;; ++ ++ drm_atomic_state_ref_counting) ++ # ++ # Determine if functions drm_atomic_state_get/put() are ++ # present. ++ # ++ # Added by commit 0853695c3ba4 ("drm: Add reference counting to ++ # drm_atomic_state") in v4.10 (2016-10-14) ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_ATOMIC_H_PRESENT) ++ #include <drm/drm_atomic.h> ++ #endif ++ void conftest_drm_atomic_state_get(void) { ++ drm_atomic_state_get(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_STATE_REF_COUNTING_PRESENT" "" "functions" ++ ;; ++ ++ vm_ops_fault_removed_vma_arg) ++ # ++ # Determine if vma.vm_ops.fault takes (vma, vmf), or just (vmf) ++ # args. Acronym key: ++ # vma: struct vm_area_struct ++ # vm_ops: struct vm_operations_struct ++ # vmf: struct vm_fault ++ # ++ # The redundant vma arg was removed from BOTH vma.vm_ops.fault and ++ # vma.vm_ops.page_mkwrite, with the following commit: ++ # ++ # 2017-02-24 11bac80004499ea59f361ef2a5516c84b6eab675 ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_vm_ops_fault_removed_vma_arg(void) { ++ struct vm_operations_struct vm_ops; ++ struct vm_fault *vmf; ++ (void)vm_ops.fault(vmf); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VM_OPS_FAULT_REMOVED_VMA_ARG" "" "types" ++ ;; ++ ++ pnv_npu2_init_context) ++ # ++ # Determine if the pnv_npu2_init_context() function is ++ # present. ++ # ++ CODE=" ++ #if defined(NV_ASM_POWERNV_H_PRESENT) ++ #include <linux/pci.h> ++ #include <asm/powernv.h> ++ #endif ++ void conftest_pnv_npu2_init_context(void) { ++ pnv_npu2_init_context(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_PNV_NPU2_INIT_CONTEXT_PRESENT" "" "functions" ++ ;; ++ ++ drm_driver_unload_has_int_return_type) ++ # ++ # Determine if drm_driver::unload() returns integer value, which has ++ # been changed to void by commit - ++ # ++ # 2017-01-06 11b3c20bdd15d17382068be569740de1dccb173d ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ int conftest_drm_driver_unload_has_int_return_type(struct drm_driver *drv) { ++ return drv->unload(NULL /* dev */); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_UNLOAD_HAS_INT_RETURN_TYPE" "" "types" ++ ;; ++ ++ kref_has_refcount_of_type_refcount_t) ++ CODE=" ++ #include <linux/kref.h> ++ ++ refcount_t conftest_kref_has_refcount_of_type_refcount_t(struct kref *ref) { ++ return ref->refcount; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_KREF_HAS_REFCOUNT_OF_TYPE_REFCOUNT_T" "" "types" ++ ;; ++ ++ is_export_symbol_present_*) ++ export_symbol_present_conftest $(echo $1 | cut -f5- -d_) ++ ;; ++ ++ is_export_symbol_gpl_*) ++ export_symbol_gpl_conftest $(echo $1 | cut -f5- -d_) ++ ;; ++ ++ drm_atomic_helper_disable_all) ++ # ++ # Determine if the function drm_atomic_helper_disable_all() is ++ # present. ++ # ++ # drm_atomic_helper_disable_all() has been added by: ++ # 2015-12-02 1494276000db789c6d2acd85747be4707051c801 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_ATOMIC_HELPER_H_PRESENT) ++ #include <drm/drm_atomic_helper.h> ++ #endif ++ void conftest_drm_atomic_helper_disable_all(void) { ++ drm_atomic_helper_disable_all(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_DISABLE_ALL_PRESENT" "" "functions" ++ ;; ++ ++ drm_atomic_helper_set_config) ++ # ++ # Determine if drm_atomic_helper_set_config() has 'ctx' argument. ++ # ++ # drm_atomic_helper_set_config() was added by: ++ # 2014-06-27 042652ed95996a9ef6dcddddc53b5d8bc7fa887e ++ # and it has been updated to take ctx parameter by: ++ # 2017-03-22 a4eff9aa6db8eb3d1864118f3558214b26f630b4 ++ # ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRM_ATOMIC_HELPER_H_PRESENT) ++ #include <drm/drm_atomic_helper.h> ++ #endif ++ void conftest_drm_atomic_helper_set_config(void) { ++ drm_atomic_helper_set_config(); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#undef NV_DRM_ATOMIC_HELPER_SET_CONFIG_PRESENT" | append_conftest "functions" ++ else ++ echo "#define NV_DRM_ATOMIC_HELPER_SET_CONFIG_PRESENT" | append_conftest "functions" ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <drm/drm_atomic_helper.h> ++ int drm_atomic_helper_set_config(struct drm_mode_set *set, ++ struct drm_modeset_acquire_ctx *ctx) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DRM_ATOMIC_HELPER_SET_CONFIG_HAS_CTX_ARG" | append_conftest "types" ++ rm -f conftest$$.o ++ else ++ echo "#undef NV_DRM_ATOMIC_HELPER_SET_CONFIG_HAS_CTX_ARG" | append_conftest "types" ++ fi ++ fi ++ ;; ++ ++ drm_atomic_helper_crtc_destroy_state_has_crtc_arg) ++ # ++ # Determine if __drm_atomic_helper_crtc_destroy_state() has 'crtc' ++ # argument. ++ # ++ # __drm_atomic_helper_crtc_destroy_state() is updated to drop ++ # crtc argument by: ++ # 2016-05-09 ec2dc6a0fe38de8d73a7b7638a16e7d33a19a5eb ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_ATOMIC_HELPER_H_PRESENT) ++ #include <drm/drm_atomic_helper.h> ++ #endif ++ void conftest_drm_atomic_helper_crtc_destroy_state_has_crtc_arg(void) { ++ __drm_atomic_helper_crtc_destroy_state(NULL, NULL); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_CRTC_DESTROY_STATE_HAS_CRTC_ARG" "" "types" ++ ;; ++ ++ drm_atomic_helper_connector_dpms) ++ # ++ # Determine if the function drm_atomic_helper_connector_dpms() is present. ++ # ++ # drm_atomic_helper_connector_dpms() was removed by: ++ # 2017-07-25 7d902c05b480cc44033dcb56e12e51b082656b42 ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_ATOMIC_HELPER_H_PRESENT) ++ #include <drm/drm_atomic_helper.h> ++ #endif ++ void conftest_drm_atomic_helper_connector_dpms(void) { ++ drm_atomic_helper_connector_dpms(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_CONNECTOR_DPMS_PRESENT" "" "functions" ++ ;; ++ ++ backlight_device_register) ++ # ++ # Determine if the backlight_device_register() function is present ++ # and how many arguments it takes. ++ # ++ # Don't try to support the 4-argument form of backlight_device_register(). ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/backlight.h> ++ #if !defined(CONFIG_BACKLIGHT_CLASS_DEVICE) ++ #error Backlight class device not enabled ++ #endif ++ void conftest_backlight_device_register(void) { ++ backlight_device_register(NULL, NULL, NULL, NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_BACKLIGHT_DEVICE_REGISTER_PRESENT" | append_conftest "functions" ++ return ++ else ++ echo "#undef NV_BACKLIGHT_DEVICE_REGISTER_PRESENT" | append_conftest "functions" ++ return ++ fi ++ ;; ++ ++ backlight_properties_type) ++ # ++ # Determine if the backlight_properties structure has a 'type' field ++ # and whether BACKLIGHT_RAW is defined. ++ # ++ CODE=" ++ #include <linux/backlight.h> ++ void conftest_backlight_props_type(void) { ++ struct backlight_properties tmp; ++ tmp.type = BACKLIGHT_RAW; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_BACKLIGHT_PROPERTIES_TYPE_PRESENT" "" "types" ++ ;; ++ ++ register_acpi_notifier) ++ # ++ # Determine if the register_acpi_notifier() and unregister_acpi_notifier() ++ # functions are present. ++ # ++ # register_acpi_notifier() and unregister_acpi_notifier() are ++ # added by: ++ # 2008-01-25 9ee85241fdaab358dff1d8647f20a478cfa512a1 ++ # ++ CODE=" ++ #include <acpi/acpi_bus.h> ++ int conftest_register_acpi_notifier(void) { ++ return register_acpi_notifier(); ++ }" ++ compile_check_conftest "$CODE" "NV_REGISTER_ACPI_NOTIFER_PRESENT" "" "functions" ++ ;; ++ ++ timer_setup) ++ # ++ # Determine if the function timer_setup() is present. ++ # ++ # timer_setup() was added by: ++ # 2017-09-28 686fef928bba6be13cabe639f154af7d72b63120 ++ # ++ CODE=" ++ #include <linux/timer.h> ++ int conftest_timer_setup(void) { ++ return timer_setup(); ++ }" ++ compile_check_conftest "$CODE" "NV_TIMER_SETUP_PRESENT" "" "functions" ++ ;; ++ ++ radix_tree_replace_slot) ++ # ++ # Determine if the radix_tree_replace_slot() function is ++ # present and how many arguments it takes. ++ # ++ # radix_tree_replace_slot added ++ # 2006-12-06 7cf9c2c76c1a17b32f2da85b50cd4fe468ed44b5 ++ # root parameter added to radix_tree_replace_slot in 4.10 (but the symbol was not exported) ++ # 2016-12-12 6d75f366b9242f9b17ed7d0b0604d7460f818f21 ++ # radix_tree_replace_slot symbol export was introduced in 4.11 ++ # 2017-10-11 10257d719686706aa669b348309cfd9fd9783ad9 ++ # ++ CODE=" ++ #include <linux/bug.h> ++ #include <linux/version.h> ++ void conftest_radix_tree_replace_slot(void) { ++ BUILD_BUG_ON(LINUX_VERSION_CODE < KERNEL_VERSION(4, 10, 0) || LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0)); ++ }" ++ compile_check_conftest "$CODE" "NV_RADIX_TREE_REPLACE_SLOT_PRESENT" "" "functions" ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/radix-tree.h> ++ void conftest_radix_tree_replace_slot(void) { ++ radix_tree_replace_slot(NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_RADIX_TREE_REPLACE_SLOT_ARGUMENT_COUNT 2" | append_conftest "functions" ++ return ++ fi ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/radix-tree.h> ++ void conftest_radix_tree_replace_slot(void) { ++ radix_tree_replace_slot(NULL, NULL, NULL); ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_RADIX_TREE_REPLACE_SLOT_ARGUMENT_COUNT 3" | append_conftest "functions" ++ return ++ else ++ echo "#error radix_tree_replace_slot() conftest failed!" | append_conftest "functions" ++ fi ++ ;; ++ ++ drm_old_atomic_state_iterators_present) ++ # ++ # Determine if the old atomic state iterators ++ # for_each_crtc_in_state(), for_each_connector_in_state() and ++ # for_each_plane_in_state() are present. ++ # ++ # These old atomic state iterators were added by: ++ # 2015-04-10 df63b9994eaf942afcdb946d27a28661d7dfbf2a ++ # and they are removed by: ++ # 2017-07-19 77ac3b00b13185741effd0d5e2f1f05e4bfef7dc ++ # ++ CODE=" ++ #include <drm/drmP.h> ++ #include <drm/drm_atomic.h> ++ void conftest_drm_old_atomic_state_iterators_present(void) { ++ struct drm_crtc_state *crtc_state; ++ struct drm_atomic_state *state; ++ struct drm_crtc *crtc; ++ int i; ++ ++ for_each_crtc_in_state(state, crtc, crtc_state, i) { ++ } ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_OLD_ATOMIC_STATE_ITERATORS_PRESENT" | append_conftest "types" ++ ;; ++ ++ drm_mode_object_find_has_file_priv_arg) ++ # ++ # Determine if drm_mode_object_find() has 'file_priv' arguments. ++ # ++ # The function drm_mode_object_find() was added by: ++ # 2008-11-07 f453ba0460742ad027ae0c4c7d61e62817b3e7ef ++ # and it is updated to take 'file_priv' argument by: ++ # 2017-03-14 418da17214aca5ef5f0b6f7588905ee7df92f98f ++ # ++ CODE=" ++ #include <drm/drm_mode_object.h> ++ void conftest_drm_mode_object_find_has_file_priv_arg( ++ struct drm_device *dev, ++ struct drm_file *file_priv, ++ uint32_t id, ++ uint32_t type) { ++ (void)drm_mode_object_find(dev, file_priv, id, type); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_MODE_OBJECT_FIND_HAS_FILE_PRIV_ARG" | append_conftest "types" ++ ;; ++ kmem_cache_create_usercopy) ++ # ++ # Determine if the kmem_cache_create_usercopy function exists. ++ # ++ # This function was added by: ++ # 2017-06-10 8eb8284b412906181357c2b0110d879d5af95e52 ++ CODE=" ++ #include <linux/slab.h> ++ void kmem_cache_create_usercopy(void) { ++ kmem_cache_create_usercopy(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_KMEM_CACHE_CREATE_USERCOPY_PRESENT" "" "functions" ++ ;; ++ ++ drm_connector_funcs_have_mode_in_name) ++ # ++ # Determine if _mode_ is present in connector function names. ++ # ++ # _mode_ has been dropped from connector function names by commits: ++ # 2018-07-09 c555f02371c338b06752577aebf738dbdb6907bd ++ # 2018-07-09 cde4c44d8769c1be16074c097592c46c7d64092b ++ # 2018-07-09 97e14fbeb53fe060c5f6a7a07e37fd24c087ed0c ++ # ++ CODE=" ++ #include <drm/drm_connector.h> ++ void conftest_drm_connector_funcs_have_mode_in_name(void) { ++ drm_mode_connector_attach_encoder(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_CONNECTOR_FUNCS_HAVE_MODE_IN_NAME" "" "functions" ++ ;; ++ ++ vm_fault_t) ++ # ++ # Determine if vm_fault_t is present ++ # ++ # Added by commit 1c8f422059ae5da07db7406ab916203f9417e396 ("mm: ++ # change return type to vm_fault_t") in v4.17 (2018-04-05) ++ # ++ CODE=" ++ #include <linux/mm.h> ++ vm_fault_t conftest_vm_fault_t; ++ " ++ compile_check_conftest "$CODE" "NV_VM_FAULT_T_IS_PRESENT" "" "types" ++ ;; ++ ++ vmf_insert_pfn) ++ # ++ # Determine if the function vmf_insert_pfn() is ++ # present. ++ # ++ # Added by commit 1c8f422059ae5da07db7406ab916203f9417e396 ("mm: ++ # change return type to vm_fault_t") in v4.17 (2018-04-05) ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_vmf_insert_pfn(void) { ++ vmf_insert_pfn(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VMF_INSERT_PFN_PRESENT" "" "functions" ++ ;; ++ ++ do_gettimeofday) ++ # ++ # Determine if the function do_gettimeofday() is ++ # present. ++ # ++ # Added by commit 7a2deb32924142696b8174cdf9b38cd72a11fc96 ++ # (2002-02-04) in v2.5.0, moved from linux/time.h to ++ # linux/timekeeping.h by commit ++ # 8b094cd03b4a3793220d8d8d86a173bfea8c285b (2014-07-16) in v3.17, ++ # and removed by e4b92b108c6cd6b311e4b6e85d6a87a34599a6e3 ++ # (2018-12-07). ++ # ++ # Header file linux/ktime.h added by commit ++ # 97fc79f97b1111c80010d34ee66312b88f531e41 (2006-06-09) in v2.6.16, ++ # includes linux/time.h and/or linux/timekeeping.h. ++ # ++ CODE=" ++ #include <linux/time.h> ++ #if defined(NV_LINUX_KTIME_H_PRESENT) ++ #include <linux/ktime.h> ++ #endif ++ void conftest_do_gettimeofday(void) { ++ do_gettimeofday(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DO_GETTIMEOFDAY_PRESENT" "" "functions" ++ ;; ++ ++ drm_framebuffer_get) ++ # ++ # Determine if the function drm_framebuffer_get() is present. ++ # ++ # Added by commit a4a69da06bc11a937a6e417938b1bb698ee1fa46 (drm: ++ # Introduce drm_framebuffer_{get,put}()) on 2017-02-28. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_FRAMEBUFFER_H_PRESENT) ++ #include <drm/drm_framebuffer.h> ++ #endif ++ ++ void conftest_drm_framebuffer_get(void) { ++ drm_framebuffer_get(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_FRAMEBUFFER_GET_PRESENT" "" "functions" ++ ;; ++ ++ drm_gem_object_get) ++ # ++ # Determine if the function drm_gem_object_get() is present. ++ # ++ # Added by commit e6b62714e87c8811d5564b6a0738dcde63a51774 (drm: ++ # Introduce drm_gem_object_{get,put}()) on 2017-02-28. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_GEM_H_PRESENT) ++ #include <drm/drm_gem.h> ++ #endif ++ void conftest_drm_gem_object_get(void) { ++ drm_gem_object_get(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_GEM_OBJECT_GET_PRESENT" "" "functions" ++ ;; ++ ++ drm_dev_put) ++ # ++ # Determine if the function drm_dev_put() is present. ++ # ++ # Added by commit 9a96f55034e41b4e002b767e9218d55f03bdff7d (drm: ++ # introduce drm_dev_{get/put} functions) on 2017-09-26. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ void conftest_drm_dev_put(void) { ++ drm_dev_put(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DEV_PUT_PRESENT" "" "functions" ++ ;; ++ ++ drm_connector_list_iter) ++ # ++ # Determine if the drm_connector_list_iter struct is present. ++ # ++ # Added by commit 613051dac40da1751ab269572766d3348d45a197 ("drm: ++ # locking&new iterators for connector_list") in v4.11 (2016-12-14). ++ # ++ CODE=" ++ #include <drm/drm_connector.h> ++ int conftest_drm_connector_list_iter(void) { ++ struct drm_connector_list_iter conn_iter; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_CONNECTOR_LIST_ITER_PRESENT" "" "types" ++ ++ # ++ # Determine if the function drm_connector_list_iter_get() is ++ # renamed to drm_connector_list_iter_begin(). ++ # ++ # Renamed by b982dab1e66d2b998e80a97acb6eaf56518988d3 (drm: Rename ++ # connector list iterator API) in v4.12 (2017-02-28). ++ # ++ CODE=" ++ #if defined(NV_DRM_DRM_CONNECTOR_H_PRESENT) ++ #include <drm/drm_connector.h> ++ #endif ++ void conftest_drm_connector_list_iter_begin(void) { ++ drm_connector_list_iter_begin(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_CONNECTOR_LIST_ITER_BEGIN_PRESENT" "" "functions" ++ ;; ++ ++ drm_atomic_helper_swap_state_has_stall_arg) ++ # ++ # Determine if drm_atomic_helper_swap_state() has 'stall' argument. ++ # ++ # drm_atomic_helper_swap_state() function prototype updated to take ++ # 'state' and 'stall' arguments by commit ++ # 5e84c2690b805caeff3b4c6c9564c7b8de54742d (drm/atomic-helper: ++ # Massage swap_state signature somewhat) ++ # in v4.8 (2016-06-10). ++ # ++ CODE=" ++ #include <drm/drm_atomic_helper.h> ++ void conftest_drm_atomic_helper_swap_state_has_stall_arg( ++ struct drm_atomic_state *state, ++ bool stall) { ++ (void)drm_atomic_helper_swap_state(state, stall); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_SWAP_STATE_HAS_STALL_ARG" | append_conftest "types" ++ ++ # ++ # Determine if drm_atomic_helper_swap_state() returns int. ++ # ++ # drm_atomic_helper_swap_state() function prototype ++ # updated to return int by commit ++ # c066d2310ae9bbc695c06e9237f6ea741ec35e43 (drm/atomic: Change ++ # drm_atomic_helper_swap_state to return an error.) in v4.14 ++ # (2017-07-11). ++ # ++ CODE=" ++ #include <drm/drm_atomic_helper.h> ++ int conftest_drm_atomic_helper_swap_state_return_int( ++ struct drm_atomic_state *state, ++ bool stall) { ++ return drm_atomic_helper_swap_state(state, stall); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_SWAP_STATE_RETURN_INT" | append_conftest "types" ++ ;; ++ ++ dma_direct_map_resource) ++ # ++ # Determine whether dma_is_direct() exists. ++ # ++ # dma_is_direct() was added by commit 356da6d0cde3 ("dma-mapping: ++ # bypass indirect calls for dma-direct") in (2018-12-06). ++ # ++ # If dma_is_direct() does exist, then we assume that ++ # dma_direct_map_resource() exists. Both functions were added ++ # as part of the same patchset. ++ # ++ # The presence of dma_is_direct() and dma_direct_map_resource() ++ # means that dma_direct can perform DMA mappings itself. ++ # ++ CODE=" ++ #include <linux/dma-mapping.h> ++ void conftest_dma_is_direct(void) { ++ dma_is_direct(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DMA_IS_DIRECT_PRESENT" "" "functions" ++ ;; ++ ++ drm_driver_prime_flag_present) ++ # ++ # Determine whether driver feature flag DRIVER_PRIME is present. ++ # ++ # The DRIVER_PRIME flag was added by commit 3248877ea179 (drm: ++ # base prime/dma-buf support (v5)) in v3.4 (2011-11-25) and is ++ # removed by commit 0424fdaf883a (drm/prime: Actually remove ++ # DRIVER_PRIME everywhere) on 2019-06-17. ++ # ++ # DRIVER_PRIME definition moved from drmP.h to drm_drv.h by ++ # commit 85e634bce01a (drm: Extract drm_drv.h) in v4.10 ++ # (2016-11-14). ++ # ++ # DRIVER_PRIME define is changed to enum value by commit ++ # 0e2a933b02c9 (drm: Switch DRIVER_ flags to an enum) in v5.1 ++ # (2019-01-29). ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ ++ unsigned int drm_driver_prime_flag_present_conftest(void) { ++ return DRIVER_PRIME; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_PRIME_FLAG_PRESENT" "" "types" ++ ;; ++ ++ drm_gem_prime_export_has_dev_arg) ++ # ++ # Determine if drm_driver::gem_prime_export() has 'dev' argument. ++ # ++ # The 'dev' argument has been dropped from ++ # drm_driver::gem_prime_export() by commit e4fa8457b219 (drm/prime: ++ # Align gem_prime_export with obj_funcs.export) in v5.4-rc1 ++ # (2019-06-14). ++ # ++ CODE=" ++ #include <drm/drmP.h> ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ struct dma_buf *conftest_drm_gem_prime_export_has_dev_arg( ++ struct drm_driver *drv, ++ struct drm_device *dev, struct drm_gem_object *obj, int flags) { ++ return drv->gem_prime_export(dev, obj, flags); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_GEM_PRIME_EXPORT_HAS_DEV_ARG" "" "types" ++ ;; ++ ++ drm_connector_for_each_possible_encoder) ++ # ++ # Determine the number of arguments of the ++ # drm_connector_for_each_possible_encoder() macro. ++ # ++ # drm_connector_for_each_possible_encoder() is added by commit ++ # 83aefbb887b5 (drm: Add drm_connector_for_each_possible_encoder()) ++ # in v4.19. The definition and prorotype is changed to take only ++ # two arguments connector and encoder, by commit 62afb4ad425a ++ # (drm/connector: Allow max possible encoders to attach to a ++ # connector) in v5.5rc1. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_CONNECTOR_H_PRESENT) ++ #include <drm/drm_connector.h> ++ #endif ++ ++ void conftest_drm_connector_for_each_possible_encoder( ++ struct drm_connector *connector, ++ struct drm_encoder *encoder, ++ int i) { ++ ++ drm_connector_for_each_possible_encoder(connector, encoder, i) { ++ } ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_DRM_CONNECTOR_FOR_EACH_POSSIBLE_ENCODER_ARGUMENT_COUNT 3" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ else ++ echo "#define NV_DRM_CONNECTOR_FOR_EACH_POSSIBLE_ENCODER_ARGUMENT_COUNT 2" | append_conftest "functions" ++ fi ++ ;; ++ ++ drm_gem_object_has_resv) ++ # ++ # Determine if the 'drm_gem_object' structure has a 'resv' field. ++ # ++ # A 'resv' filed in the 'drm_gem_object' structure, is added by ++ # commit 1ba627148ef5 (drm: Add reservation_object to ++ # drm_gem_object) in v5.2. ++ # ++ CODE="$CONFTEST_PREAMBLE ++ #if defined(NV_DRM_DRM_GEM_H_PRESENT) ++ #include <drm/drm_gem.h> ++ #endif ++ ++ int conftest_drm_gem_object_has_resv(void) { ++ return offsetof(struct drm_gem_object, resv); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_GEM_OBJECT_HAS_RESV" "" "types" ++ ;; ++ ++ proc_ops) ++ # ++ # Determine if the 'struct proc_ops' type is present. ++ # ++ # Added by commit d56c0d45f0e2 ("proc: decouple proc from VFS with ++ # "struct proc_ops"") in 5.6-rc1 ++ # ++ CODE=" ++ #include <linux/proc_fs.h> ++ ++ struct proc_ops p_ops; ++ " ++ ++ compile_check_conftest "$CODE" "NV_PROC_OPS_PRESENT" "" "types" ++ ;; ++ ++ timeval) ++ # ++ # Determine if the 'struct timeval' type is present. ++ # ++ # Removed by commit c766d1472c70 ("y2038: hide ++ # timeval/timespec/itimerval/itimerspec types") in 5.6-rc3 ++ # (2020-02-20). ++ # ++ CODE=" ++ #include <linux/time.h> ++ ++ struct timeval tm; ++ " ++ ++ compile_check_conftest "$CODE" "NV_TIMEVAL_PRESENT" "" "types" ++ ;; ++ ++ ktime_get_raw_ts64) ++ # ++ # Determine if ktime_get_raw_ts64() is present ++ # ++ # Added by commit fb7fcc96a86cf ("timekeeping: Standardize on ++ # ktime_get_*() naming") in 4.18 (2018-04-27) ++ # ++ CODE=" ++ #include <linux/ktime.h> ++ void conftest_ktime_get_raw_ts64(void){ ++ ktime_get_raw_ts64(); ++ }" ++ compile_check_conftest "$CODE" "NV_KTIME_GET_RAW_TS64_PRESENT" "" "functions" ++ ;; + - nvif_parent_gpu_handle = NULL; - - return; -@@ -1212,7 +1218,11 @@ - if (!dev_handle) - return RM_ERR_INVALID_ARGUMENT; - -+#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) - status = acpi_bus_get_device(dev_handle, &device); -+#else -+ return RM_ERR_NOT_SUPPORTED; -+#endif - - if (ACPI_FAILURE(status) || !device) - return RM_ERR_INVALID_ARGUMENT; -diff -Naur a/kernel/nv.c b/kernel/nv.c ---- a/kernel/nv.c 2022-10-16 09:28:09.739226641 +0200 -+++ b/kernel/nv.c 2022-08-28 09:42:35.548184128 +0200 -@@ -752,7 +752,7 @@ - NV_SPIN_LOCK_INIT(&km_lock); - #endif - -- NV_KMEM_CACHE_CREATE(nv_stack_t_cache, NV_STACK_CACHE_STR, nv_stack_t); -+ NV_KMEM_CACHE_CREATE_USERCOPY(nv_stack_t_cache, NV_STACK_CACHE_STR, nv_stack_t); - if (nv_stack_t_cache == NULL) - { - nv_printf(NV_DBG_ERRORS, "NVRM: stack cache allocation failed!\n"); -@@ -2785,7 +2785,11 @@ - - #if defined(CONFIG_VGA_ARB) - #if defined(VGA_DEFAULT_DEVICE) -+#if defined(NV_VGA_TRYGET_PRESENT) - vga_tryget(VGA_DEFAULT_DEVICE, VGA_RSRC_LEGACY_MASK); -+#else -+ vga_get(VGA_DEFAULT_DEVICE, VGA_RSRC_LEGACY_MASK, 0); -+#endif - #endif - vga_set_legacy_decoding(dev, VGA_RSRC_NONE); - #endif -diff -Naur a/kernel/nv-dma.c b/kernel/nv-dma.c ---- a/kernel/nv-dma.c 2022-10-16 09:28:09.691227737 +0200 -+++ b/kernel/nv-dma.c 2022-08-28 09:42:35.544184215 +0200 -@@ -136,10 +136,17 @@ - return status; - } - -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) -+ dma_map->sg_map_count = dma_map_sg(&dma_map->dev->dev, -+ NV_DMA_MAP_SCATTERLIST(dma_map), -+ NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), -+ DMA_BIDIRECTIONAL); -+#else - dma_map->sg_map_count = pci_map_sg(dma_map->dev, - NV_DMA_MAP_SCATTERLIST(dma_map), - NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), - PCI_DMA_BIDIRECTIONAL); -+#endif - if (dma_map->sg_map_count == 0) - { - nv_printf(NV_DBG_ERRORS, -@@ -211,8 +218,13 @@ - - if (dma_map->sg_map_count != 0) - { -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) -+ dma_unmap_sg(&dma_map->dev->dev, NV_DMA_MAP_SCATTERLIST(dma_map), -+ NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), DMA_BIDIRECTIONAL); -+#else - pci_unmap_sg(dma_map->dev, NV_DMA_MAP_SCATTERLIST(dma_map), - NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), PCI_DMA_BIDIRECTIONAL); -+#endif - } - - *priv = dma_map->user_pages; -diff -Naur a/kernel/nv-drm.c b/kernel/nv-drm.c ---- a/kernel/nv-drm.c 2022-10-16 09:28:09.691227737 +0200 -+++ b/kernel/nv-drm.c 2022-08-28 09:42:35.544184215 +0200 -@@ -23,6 +23,11 @@ - #include <linux/file.h> - #endif - -+#include <nvidia-drm-priv.h> -+#include <nvidia-drm-ioctl.h> -+#include <nvidia-drm-gem-user-memory.h> -+#include <nvidia-drm-helper.h> -+ - #if defined(NV_DRM_DRM_DRV_H_PRESENT) - #include <drm/drm_drv.h> - #endif -@@ -55,6 +60,8 @@ - #define nv_drm_pci_exit drm_pci_exit - #endif - -+static struct nv_drm_device *dev_list = NULL; ++ ktime_get_real_ts64) ++ # ++ # Determine if ktime_get_real_ts64() is present ++ # ++ # Added by commit d6d29896c665d ("timekeeping: Provide timespec64 ++ # based interfaces") in 3.17 (2014-07-16) ++ # ++ CODE=" ++ #include <linux/ktime.h> ++ void conftest_ktime_get_real_ts64(void){ ++ ktime_get_real_ts64(); ++ }" ++ compile_check_conftest "$CODE" "NV_KTIME_GET_REAL_TS64_PRESENT" "" "functions" ++ ;; + - extern nv_linux_state_t *nv_linux_devices; - - struct nv_gem_object { -@@ -62,20 +69,35 @@ - struct page **pages; - }; - -+#if !defined(NV_DRM_DEVICE_HAS_PDEV) -+#include <drm/drm_legacy.h> -+struct nv_drm_extra_priv_data { -+ struct pci_dev *pdev; -+ struct drm_agp_head *agp; -+}; -+#endif ++ mm_has_mmap_lock) ++ # ++ # Determine if the 'mm_struct' structure has a 'mmap_lock' field. ++ # ++ # Kernel commit da1c55f1b272 ("mmap locking API: rename mmap_sem ++ # to mmap_lock") replaced the field 'mmap_sem' by 'mmap_lock' ++ # in v5.8-rc1 (2020-06-08). ++ CODE=" ++ #include <linux/mm_types.h> + - static int nv_drm_load( - struct drm_device *dev, - unsigned long flags - ) - { - nv_linux_state_t *nvl; -+#if !defined(NV_DRM_DEVICE_HAS_PDEV) -+ struct nv_drm_extra_priv_data *extra = dev->dev_private; -+#endif - - for (nvl = nv_linux_devices; nvl != NULL; nvl = nvl->next) - { -- if (nvl->dev == dev->pdev) -- { -- nvl->drm = dev; -- return 0; -- } -+#if defined(NV_DRM_DEVICE_HAS_PDEV) -+ if (nvl->dev == dev->pdev) -+#else -+ if (nvl->dev == extra->pdev) -+#endif -+ { -+ nvl->drm = dev; -+ return 0; -+ } - } - - return -ENODEV; -@@ -92,11 +114,18 @@ - ) - { - nv_linux_state_t *nvl; -+#if !defined(NV_DRM_DEVICE_HAS_PDEV) -+ struct nv_drm_extra_priv_data *extra = dev->dev_private; -+#endif - - for (nvl = nv_linux_devices; nvl != NULL; nvl = nvl->next) - { -- if (nvl->dev == dev->pdev) -- { -+#if defined(NV_DRM_DEVICE_HAS_PDEV) -+ if (nvl->dev == dev->pdev) -+#else -+ if (nvl->dev == extra->pdev) -+#endif -+ { - BUG_ON(nvl->drm != dev); - nvl->drm = NULL; - return 0; -@@ -131,32 +160,49 @@ - NV_KFREE(nv_obj, sizeof(*nv_obj)); - } - --static struct sg_table* nv_gem_prime_get_sg_table( -- struct drm_gem_object *obj --) -+static int nv_drm_get_dev_info_ioctl(struct drm_device *dev, -+ void *data, struct drm_file *filep) - { -- struct nv_gem_object *nv_obj = container_of(obj, struct nv_gem_object, base); -- int page_count = obj->size >> PAGE_SHIFT; -+ struct nv_drm_device *nv_dev = to_nv_device(dev); -+ struct drm_nvidia_get_dev_info_params *params = data; - -- return drm_prime_pages_to_sg(nv_obj->pages, page_count); --} -+ if (dev->primary == NULL) { -+ return -ENOENT; -+ } - --static void* nv_gem_prime_vmap( -- struct drm_gem_object *obj --) --{ -- struct nv_gem_object *nv_obj = container_of(obj, struct nv_gem_object, base); -- int page_count = obj->size >> PAGE_SHIFT; -+ params->gpu_id = nv_dev->gpu_info.gpu_id; -+ params->primary_index = dev->primary->index; - -- return vmap(nv_obj->pages, page_count, VM_USERMAP, PAGE_KERNEL); -+ return 0; - } - --static void nv_gem_prime_vunmap( -- struct drm_gem_object *obj, -- void *virtual --) --{ -- vunmap(virtual); -+static -+int nv_drm_get_client_capability_ioctl(struct drm_device *dev, -+ void *data, struct drm_file *filep) -+{ -+ struct drm_nvidia_get_client_capability_params *params = data; ++ int conftest_mm_has_mmap_lock(void) { ++ return offsetof(struct mm_struct, mmap_lock); ++ }" + -+ switch (params->capability) { -+#if defined(DRM_CLIENT_CAP_STEREO_3D) -+ case DRM_CLIENT_CAP_STEREO_3D: -+ params->value = filep->stereo_allowed; -+ break; -+#endif -+#if defined(DRM_CLIENT_CAP_UNIVERSAL_PLANES) -+ case DRM_CLIENT_CAP_UNIVERSAL_PLANES: -+ params->value = filep->universal_planes; -+ break; -+#endif -+#if defined(DRM_CLIENT_CAP_ATOMIC) -+ case DRM_CLIENT_CAP_ATOMIC: -+ params->value = filep->atomic; -+ break; -+#endif -+ default: -+ return -EINVAL; -+ } ++ compile_check_conftest "$CODE" "NV_MM_HAS_MMAP_LOCK" "" "types" + -+ return 0; - } - - static const struct file_operations nv_drm_fops = { -@@ -170,6 +216,43 @@ - .llseek = noop_llseek, - }; - -+static const struct drm_ioctl_desc nv_drm_ioctls[] = { -+// #if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -+// DRM_IOCTL_DEF_DRV(NVIDIA_GEM_IMPORT_NVKMS_MEMORY, -+// nv_drm_gem_import_nvkms_memory_ioctl, -+// DRM_UNLOCKED), -+// #endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */ -+// -+ DRM_IOCTL_DEF_DRV(NVIDIA_GEM_IMPORT_USERSPACE_MEMORY, -+ nv_drm_gem_import_userspace_memory_ioctl, -+ DRM_RENDER_ALLOW|DRM_UNLOCKED), -+ DRM_IOCTL_DEF_DRV(NVIDIA_GET_DEV_INFO, -+ nv_drm_get_dev_info_ioctl, -+ DRM_RENDER_ALLOW|DRM_UNLOCKED), -+ -+// #if defined(NV_DRM_FENCE_AVAILABLE) -+// DRM_IOCTL_DEF_DRV(NVIDIA_FENCE_SUPPORTED, -+// nv_drm_fence_supported_ioctl, -+// DRM_RENDER_ALLOW|DRM_UNLOCKED), -+// DRM_IOCTL_DEF_DRV(NVIDIA_FENCE_CONTEXT_CREATE, -+// nv_drm_fence_context_create_ioctl, -+// DRM_RENDER_ALLOW|DRM_UNLOCKED), -+// DRM_IOCTL_DEF_DRV(NVIDIA_GEM_FENCE_ATTACH, -+// nv_drm_gem_fence_attach_ioctl, -+// DRM_RENDER_ALLOW|DRM_UNLOCKED), -+// #endif -+ -+ DRM_IOCTL_DEF_DRV(NVIDIA_GET_CLIENT_CAPABILITY, -+ nv_drm_get_client_capability_ioctl, -+ 0), -+// #if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -+// DRM_IOCTL_DEF_DRV(NVIDIA_GET_CRTC_CRC32, -+// nv_drm_get_crtc_crc32_ioctl, -+// DRM_RENDER_ALLOW|DRM_UNLOCKED), -+// #endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */ -+}; ++ ;; + ++ pci_dev_has_skip_bus_pm) ++ # ++ # Determine if skip_bus_pm flag is present in struct pci_dev. ++ # Presence of this flag is used to determine whether a call to ++ # pci_{save/restore}_state()can be skipped and kernel PCI ++ # subsystem framework will take care of saving/restoring device ++ # state. ++ # ++ # Added by commit d491f2b75237 ("PCI: PM: Avoid possible ++ # suspend-to-idle issue") in 5.2-rc3 (2019-06-13) ++ # ++ CODE=" ++ #include <linux/pci.h> ++ void conftest_pci_dev_has_skip_bus_pm(void) { ++ struct pci_dev dev; ++ (void)dev.skip_bus_pm; ++ }" + - static struct drm_driver nv_drm_driver = { - - .driver_features = DRIVER_GEM -@@ -188,13 +271,24 @@ - .set_busid = drm_pci_set_busid, - #endif - -+#if defined(NV_DRM_DRIVER_HAS_GEM_FREE_OBJECT) - .gem_free_object = nv_gem_free, -+#endif ++ compile_check_conftest "$CODE" "NV_PCI_DEV_HAS_SKIP_BUS_PM" "" "types" ++ ;; + -+ .ioctls = nv_drm_ioctls, -+ .num_ioctls = ARRAY_SIZE(nv_drm_ioctls), - - .prime_handle_to_fd = drm_gem_prime_handle_to_fd, -- .gem_prime_export = drm_gem_prime_export, -- .gem_prime_get_sg_table = nv_gem_prime_get_sg_table, -- .gem_prime_vmap = nv_gem_prime_vmap, -- .gem_prime_vunmap = nv_gem_prime_vunmap, -+#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_CALLBACKS) -+ .gem_prime_export = nv_drm_gem_prime_export, -+ .gem_prime_get_sg_table = nv_drm_gem_prime_get_sg_table, -+ .gem_prime_vmap = nv_drm_gem_prime_vmap, -+ .gem_prime_vunmap = nv_drm_gem_prime_vunmap, -+#endif ++ vmalloc_has_pgprot_t_arg) ++ # ++ # Determine if __vmalloc has the 'pgprot' argument. ++ # ++ # The third argument to __vmalloc, page protection ++ # 'pgprot_t prot', was removed by commit 88dca4ca5a93 ++ # (mm: remove the pgprot argument to __vmalloc) ++ # in v5.8-rc1 (2020-06-01). ++ CODE=" ++ #include <linux/vmalloc.h> + -+#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ) -+ .gem_prime_res_obj = nv_drm_gem_prime_res_obj, -+#endif - - .name = "nvidia-drm", - .desc = "NVIDIA DRM driver", -@@ -202,7 +296,206 @@ - .major = 0, - .minor = 0, - .patchlevel = 0, -+ -+#if defined(NV_DRM_DRIVER_HAS_DEVICE_LIST) -+ .device_list = LIST_HEAD_INIT(nv_drm_driver.device_list), -+#elif defined(NV_DRM_DRIVER_HAS_LEGACY_DEV_LIST) -+ .legacy_dev_list = LIST_HEAD_INIT(nv_drm_driver.legacy_dev_list), -+#endif - }; -+ -+/*! -+ * Enumerate the available physical GPUs that can be used with NVKMS. -+ * -+ * \param [out] gpuInfo The information of the enumerated GPUs. -+ * It is an array of NVIDIA_MAX_GPUS elements. -+ * -+ * \return Count of enumerated gpus. -+ */ -+ -+/* -+ * Implemented based on code from drm_legacy_pci_{init,exit} -+ * Extracted from tag: v5.6.3, file: drivers/gpu/drm/drm_pci.c -+ */ -+static NvU32 nvKmsenumerateGpus(nv_gpu_info_t *gpuInfo, struct drm_driver *driver, struct pci_driver *pdriver) -+{ -+ NvU32 gpu_count = 0; -+ -+ struct pci_dev *pdev = NULL; -+ const struct pci_device_id *pid; -+ int i; -+ -+ DRM_DEBUG("\n"); -+ -+ for (i = 0; pdriver->id_table[i].vendor != 0; i++) { -+ pid = &pdriver->id_table[i]; -+ -+ /* Loop around setting up a DRM device for each PCI device -+ * matching our ID and device class. If we had the internal -+ * function that pci_get_subsys and pci_get_class used, we'd -+ * be able to just pass pid in instead of doing a two-stage -+ * thing. -+ */ -+ pdev = NULL; -+ while ((pdev = -+ pci_get_subsys(pid->vendor, pid->device, pid->subvendor, -+ pid->subdevice, pdev)) != NULL) { -+ -+ if ((pdev->class & pid->class_mask) != pid->class) -+ continue; -+ -+ /* stealth mode requires a manual probe */ -+ pci_dev_get(pdev); -+ -+ gpuInfo[i].gpu_id = pid->device; -+ gpuInfo[i].pci_info.domain = pci_domain_nr(pdev->bus); -+ gpuInfo[i].pci_info.bus = pdev->bus->number; -+ gpuInfo[i].pci_info.slot = PCI_SLOT(pdev->devfn); -+ gpuInfo[i].pci_info.function = PCI_FUNC(pdev->devfn); -+ gpuInfo[i].os_dev_ptr = pdev; -+ gpu_count += 1; -+ } -+ } -+ return gpu_count; -+} ++ void conftest_vmalloc_has_pgprot_t_arg(void) { ++ pgprot_t prot; ++ (void)__vmalloc(0, 0, prot); ++ }" + -+/* -+ * Helper function for allocate/register DRM device for given NVIDIA GPU ID. -+ */ -+static void nv_drm_register_drm_device(const nv_gpu_info_t *gpu_info) -+{ -+ struct nv_drm_device *nv_dev = NULL; -+ struct drm_device *dev = NULL; -+ struct nv_drm_extra_priv_data *extra; -+ struct pci_dev *pdev = gpu_info->os_dev_ptr; ++ compile_check_conftest "$CODE" "NV_VMALLOC_HAS_PGPROT_T_ARG" "" "types" ++ ++ ;; + -+ DRM_DEBUG( -+ "Registering device for NVIDIA GPU ID 0x08%x", -+ gpu_info->gpu_id); ++ drm_gem_object_put_unlocked) ++ # ++ # Determine if the function drm_gem_object_put_unlocked() is present. ++ # ++ # In v5.9-rc1, commit 2f4dd13d4bb8 ("drm/gem: add ++ # drm_gem_object_put helper") removes drm_gem_object_put_unlocked() ++ # function and replace its definition by transient macro. Commit ++ # ab15d56e27be ("drm: remove transient ++ # drm_gem_object_put_unlocked()") finally removes ++ # drm_gem_object_put_unlocked() macro. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif + -+ /* Allocate NVIDIA-DRM device */ ++ #if defined(NV_DRM_DRM_GEM_H_PRESENT) ++ #include <drm/drm_gem.h> ++ #endif ++ void conftest_drm_gem_object_put_unlocked(void) { ++ drm_gem_object_put_unlocked(); ++ }" + -+ nv_dev = nv_drm_calloc(1, sizeof(*nv_dev)); ++ compile_check_conftest "$CODE" "NV_DRM_GEM_OBJECT_PUT_UNLOCK_PRESENT" "" "functions" ++ ;; + -+ if (nv_dev == NULL) { -+ NV_DRM_LOG_ERR( -+ "Failed to allocate memmory for NVIDIA-DRM device object"); -+ return; -+ } ++ drm_display_mode_has_vrefresh) ++ # ++ # Determine if the 'drm_display_mode' structure has a 'vrefresh' ++ # field. ++ # ++ # Removed by commit 0425662fdf05 ("drm: Nuke mode->vrefresh") in ++ # v5.9-rc1. ++ # ++ CODE=" ++ #include <drm/drm_modes.h> + -+ nv_dev->gpu_info = *gpu_info; ++ int conftest_drm_display_mode_has_vrefresh(void) { ++ return offsetof(struct drm_display_mode, vrefresh); ++ }" + -+#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -+ mutex_init(&nv_dev->lock); -+#endif ++ compile_check_conftest "$CODE" "NV_DRM_DISPLAY_MODE_HAS_VREFRESH" "types" ++ ++ ;; ++ ++ drm_driver_master_set_has_int_return_type) ++ # ++ # Determine if drm_driver::master_set() returns integer value ++ # ++ # Changed to void by commit 907f53200f98 ("drm: vmwgfx: remove ++ # drm_driver::master_set() return type") in v5.9-rc1. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ ++ int conftest_drm_driver_master_set_has_int_return_type(struct drm_driver *drv, ++ struct drm_device *dev, struct drm_file *file_priv, bool from_open) { ++ ++ return drv->master_set(dev, file_priv, from_open); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_SET_MASTER_HAS_INT_RETURN_TYPE" "" "types" ++ ;; ++ ++ drm_driver_has_gem_free_object) ++ # ++ # Determine if the 'drm_driver' structure has a 'gem_free_object' ++ # function pointer. ++ # ++ # drm_driver::gem_free_object is removed by commit 1a9458aeb8eb ++ # ("drm: remove drm_driver::gem_free_object") in v5.9-rc1. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif ++ ++ int conftest_drm_driver_has_gem_free_object(void) { ++ return offsetof(struct drm_driver, gem_free_object); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_HAS_GEM_FREE_OBJECT" "" "types" ++ ;; ++ ++ vga_tryget) ++ # ++ # Determine if vga_tryget() is present ++ # ++ # vga_tryget() was removed by commit f369bc3f9096 ("vgaarb: mark ++ # vga_tryget static") in v5.9-rc1 (2020-08-01). ++ # ++ CODE=" ++ #include <linux/vgaarb.h> ++ void conftest_vga_tryget(void) { ++ vga_tryget(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_VGA_TRYGET_PRESENT" "" "functions" ++ ;; ++ ++ pci_channel_state) ++ # ++ # Determine if pci_channel_state enum type is present. ++ # ++ # pci_channel_state was removed by commit 16d79cd4e23b ("PCI: Use ++ # 'pci_channel_state_t' instead of 'enum pci_channel_state'") in ++ # v5.9-rc1 (2020-07-02). ++ # ++ CODE=" ++ #include <linux/pci.h> ++ ++ enum pci_channel_state state; ++ " ++ ++ compile_check_conftest "$CODE" "NV_PCI_CHANNEL_STATE_PRESENT" "" "types" ++ ;; ++ ++ drm_prime_pages_to_sg_has_drm_device_arg) ++ # ++ # Determine if drm_prime_pages_to_sg() has 'dev' argument. ++ # ++ # drm_prime_pages_to_sg() is updated to take 'dev' argument by commit ++ # 707d561f77b5 ("drm: allow limiting the scatter list size."). ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ #if defined(NV_DRM_DRM_PRIME_H_PRESENT) ++ #include <drm/drm_prime.h> ++ #endif ++ ++ struct sg_table *drm_prime_pages_to_sg(struct drm_device *dev, ++ struct page **pages, ++ unsigned int nr_pages) { ++ return 0; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_PRIME_PAGES_TO_SG_HAS_DRM_DEVICE_ARG" "" "types" ++ ;; ++ ++ drm_driver_has_gem_prime_callbacks) ++ # ++ # Determine if drm_driver structure has the GEM and PRIME callback ++ # function pointers. ++ # ++ # The GEM and PRIME callback are removed from drm_driver ++ # structure, by commit d693def4fd1c ("drm: Remove obsolete GEM and ++ # PRIME callbacks from struct drm_driver"). ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif + -+ /* Allocate DRM device */ ++ void conftest_drm_driver_has_gem_and_prime_callbacks(void) { ++ struct drm_driver drv; + -+ dev = drm_dev_alloc(&nv_drm_driver, &pdev->dev); ++ drv.gem_prime_pin = 0; ++ drv.gem_prime_get_sg_table = 0; ++ drv.gem_prime_vmap = 0; ++ drv.gem_prime_vunmap = 0; ++ drv.gem_vm_ops = 0; ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_DRIVER_HAS_GEM_PRIME_CALLBACKS" "" "types" ++ ;; ++ ++ drm_crtc_atomic_check_has_atomic_state_arg) ++ # ++ # Determine if drm_crtc_helper_funcs::atomic_check takes 'state' ++ # argument of 'struct drm_atomic_state' type. ++ # ++ # The commit 29b77ad7b9ca ("drm/atomic: Pass the full state to CRTC ++ # atomic_check") passed the full atomic state to ++ # drm_crtc_helper_funcs::atomic_check() ++ # ++ # To test the signature of drm_crtc_helper_funcs::atomic_check(), ++ # declare a function prototype with typeof ::atomic_check(), and then ++ # define the corresponding function implementation with the expected ++ # signature. Successful compilation indicates that ::atomic_check() ++ # has the expected signature. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <drm/drm_modeset_helper_vtables.h> ++ ++ static const struct drm_crtc_helper_funcs *funcs; ++ typeof(*funcs->atomic_check) conftest_drm_crtc_atomic_check_has_atomic_state_arg; ++ ++ int conftest_drm_crtc_atomic_check_has_atomic_state_arg( ++ struct drm_crtc *crtc, struct drm_atomic_state *state) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_DRM_CRTC_ATOMIC_CHECK_HAS_ATOMIC_STATE_ARG" | append_conftest "types" ++ else ++ echo "#undef NV_DRM_CRTC_ATOMIC_CHECK_HAS_ATOMIC_STATE_ARG" | append_conftest "types" ++ fi ++ ;; ++ ++ drm_gem_object_vmap_has_map_arg) ++ # ++ # Determine if drm_gem_object_funcs::vmap takes 'map' ++ # argument of 'struct dma_buf_map' type. ++ # ++ # The commit 49a3f51dfeee ("drm/gem: Use struct dma_buf_map in GEM ++ # vmap ops and convert GEM backends") update ++ # drm_gem_object_funcs::vmap to take 'map' argument. ++ # ++ CODE=" ++ #include <drm/drm_gem.h> ++ int conftest_drm_gem_object_vmap_has_map_arg( ++ struct drm_gem_object *obj, struct dma_buf_map *map) { ++ return obj->funcs->vmap(obj, map); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_GEM_OBJECT_VMAP_HAS_MAP_ARG" "" "types" ++ ;; ++ ++ unsafe_follow_pfn) ++ # ++ # Determine if unsafe_follow_pfn() is present. ++ # ++ # unsafe_follow_pfn() was added by commit 69bacee7f9ad ++ # ("mm: Add unsafe_follow_pfn") in v5.13-rc1. ++ # ++ CODE=" ++ #include <linux/mm.h> ++ void conftest_unsafe_follow_pfn(void) { ++ unsafe_follow_pfn(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_UNSAFE_FOLLOW_PFN_PRESENT" "" "functions" ++ ;; ++ ++ drm_plane_atomic_check_has_atomic_state_arg) ++ # ++ # Determine if drm_plane_helper_funcs::atomic_check takes 'state' ++ # argument of 'struct drm_atomic_state' type. ++ # ++ # The commit 7c11b99a8e58 ("drm/atomic: Pass the full state to ++ # planes atomic_check") passed the full atomic state to ++ # drm_plane_helper_funcs::atomic_check() ++ # ++ # To test the signature of drm_plane_helper_funcs::atomic_check(), ++ # declare a function prototype with typeof ::atomic_check(), and then ++ # define the corresponding function implementation with the expected ++ # signature. Successful compilation indicates that ::atomic_check() ++ # has the expected signature. ++ # ++ echo "$CONFTEST_PREAMBLE ++ #include <drm/drm_modeset_helper_vtables.h> ++ ++ static const struct drm_plane_helper_funcs *funcs; ++ typeof(*funcs->atomic_check) conftest_drm_plane_atomic_check_has_atomic_state_arg; ++ ++ int conftest_drm_plane_atomic_check_has_atomic_state_arg( ++ struct drm_plane *plane, struct drm_atomic_state *state) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ echo "#define NV_DRM_PLANE_ATOMIC_CHECK_HAS_ATOMIC_STATE_ARG" | append_conftest "types" ++ else ++ echo "#undef NV_DRM_PLANE_ATOMIC_CHECK_HAS_ATOMIC_STATE_ARG" | append_conftest "types" ++ fi ++ ;; ++ ++ drm_device_has_pdev) ++ # ++ # Determine if the 'drm_device' structure has a 'pdev' field. ++ # ++ # Removed by commit b347e04452ff ("drm: Remove pdev field from ++ # struct drm_device") in v5.14-rc1. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif + -+ if (dev == NULL) { -+ NV_DRM_DEV_LOG_ERR(nv_dev, "Failed to allocate device"); -+ goto failed_drm_alloc; -+ } ++ #if defined(NV_DRM_DRM_DEVICE_H_PRESENT) ++ #include <drm/drm_device.h> ++ #endif + -+ dev->dev_private = nv_dev; -+ nv_dev->dev = dev; ++ int conftest_drm_device_has_pdev(void) { ++ return offsetof(struct drm_device, pdev); ++ }" + -+#if defined(NV_DRM_DEVICE_HAS_PDEV) -+ dev->pdev = pdev; -+#else -+ extra = kzalloc(sizeof(*extra), GFP_KERNEL); -+ extra->pdev = pdev; -+ dev->dev_private = extra; -+#endif ++ compile_check_conftest "$CODE" "NV_DRM_DEVICE_HAS_PDEV" "" "types" ++ ;; + -+ /* Register DRM device to DRM sub-system */ ++ acpi_bus_get_device) ++ # ++ # Determine if the acpi_bus_get_device() function is present ++ # ++ # acpi_bus_get_device() was removed by commit ac2a3feefad5 ++ # ("ACPI: bus: Eliminate acpi_bus_get_device()") in ++ # v5.18-rc2 (2022-04-05). ++ # ++ CODE=" ++ #include <linux/acpi.h> ++ int conftest_acpi_bus_get_device(void) { ++ return acpi_bus_get_device(); ++ }" ++ compile_check_conftest "$CODE" "NV_ACPI_BUS_GET_DEVICE_PRESENT" "" "functions" ++ ;; + -+ if (drm_dev_register(dev, 0) != 0) { -+ NV_DRM_DEV_LOG_ERR(nv_dev, "Failed to register device"); -+ goto failed_drm_register; -+ } ++ dma_resv_add_fence) ++ # ++ # Determine if the dma_resv_add_fence() function is present. ++ # ++ # dma_resv_add_excl_fence() and dma_resv_add_shared_fence() were ++ # removed and replaced with dma_resv_add_fence() by commit ++ # 73511edf8b19 ("dma-buf: specify usage while adding fences to ++ # dma_resv obj v7") in linux-next, expected in v5.19-rc1. ++ # ++ CODE=" ++ #if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ #include <linux/dma-resv.h> ++ #endif ++ void conftest_dma_resv_add_fence(void) { ++ dma_resv_add_fence(); ++ }" + -+ /* Add NVIDIA-DRM device into list */ ++ compile_check_conftest "$CODE" "NV_DMA_RESV_ADD_FENCE_PRESENT" "" "functions" ++ ;; + -+ nv_dev->next = dev_list; -+ dev_list = nv_dev; ++ dma_resv_reserve_fences) ++ # ++ # Determine if the dma_resv_reserve_fences() function is present. ++ # ++ # dma_resv_reserve_shared() was removed and replaced with ++ # dma_resv_reserve_fences() by commit c8d4c18bfbc4 ++ # ("dma-buf/drivers: make reserving a shared slot mandatory v4") in ++ # linux-next, expected in v5.19-rc1. ++ # ++ CODE=" ++ #if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ #include <linux/dma-resv.h> ++ #endif ++ void conftest_dma_resv_reserve_fences(void) { ++ dma_resv_reserve_fences(); ++ }" + -+ return; /* Success */ ++ compile_check_conftest "$CODE" "NV_DMA_RESV_RESERVE_FENCES_PRESENT" "" "functions" ++ ;; + -+failed_drm_register: ++ reservation_object_reserve_shared_has_num_fences_arg) ++ # ++ # Determine if reservation_object_reserve_shared() has 'num_fences' ++ # argument. ++ # ++ # reservation_object_reserve_shared() function prototype was updated ++ # to take 'num_fences' argument by commit ca05359f1e64 ("dma-buf: ++ # allow reserving more than one shared fence slot") in v4.21-rc1 ++ # (2018-12-14). ++ # ++ CODE=" ++ #include <linux/reservation.h> ++ void conftest_reservation_object_reserve_shared_has_num_fences_arg( ++ struct reservation_object *obj, ++ unsigned int num_fences) { ++ (void) reservation_object_reserve_shared(obj, num_fences); ++ }" + -+ nv_drm_dev_free(dev); ++ compile_check_conftest "$CODE" "NV_RESERVATION_OBJECT_RESERVE_SHARED_HAS_NUM_FENCES_ARG" "" "types" ++ ;; + -+failed_drm_alloc: ++ acpi_video_backlight_use_native) ++ # ++ # Determine if acpi_video_backlight_use_native() function is present ++ # ++ # acpi_video_backlight_use_native was added by commit 2600bfa3df99 ++ # (ACPI: video: Add acpi_video_backlight_use_native() helper) for ++ # v6.0 (2022-08-17). Note: the include directive for <linux/types.h> ++ # in this conftest is necessary in order to support kernels between ++ # commit 0b9f7d93ca61 ("ACPI / i915: ignore firmware requests for ++ # backlight change") for v3.16 (2014-07-07) and commit 3bd6bce369f5 ++ # ("ACPI / video: Port to new backlight interface selection API") ++ # for v4.2 (2015-07-16). Kernels within this range use the 'bool' ++ # type and the related 'false' value in <acpi/video.h> without first ++ # including the definitions of that type and value. ++ # ++ # Building code that includes <acpi/video.h> was broken in a similar ++ # manner when building a kernel without ACPI support enabled, for a ++ # brief period between commit e92a71624025 on 2010-01-12 ("ACPI: ++ # Export EDID blocks to the kernel"), which added a stub function ++ # to <acpi/video.h> that returned -ENODEV without including any ++ # headers that defined ENODEV (or any headers at all), and commit ++ # b72512ed706e on 2010-09-05 ("ACPI: video: fix build for ++ # CONFIG_ACPI=n"), which added an <include/errno.h>. Linux 2.6.35 ++ # and 2.6.36 were released with <acpi/video.h> broken in this way. ++ # ++ CODE=" ++ #include <linux/types.h> ++ #include <linux/errno.h> ++ #include <acpi/video.h> ++ void conftest_acpi_video_backglight_use_native(void) { ++ acpi_video_backlight_use_native(0); ++ }" + -+ nv_drm_free(nv_dev); ++ compile_check_conftest "$CODE" "NV_ACPI_VIDEO_BACKLIGHT_USE_NATIVE" "" "functions" ++ ;; ++ esac +} + -+/* -+ * Enumerate NVIDIA GPUs and allocate/register DRM device for each of them. -+ */ -+int nv_drm_probe_devices(struct drm_driver *driver, struct pci_driver *pdriver) -+{ -+ nv_gpu_info_t *gpu_info = NULL; -+ NvU32 gpu_count = 0; -+ NvU32 i; -+ -+ int ret = 0; ++case "$6" in ++ cc_sanity_check) ++ # ++ # Check if the selected compiler can create object files ++ # in the current environment. ++ # ++ VERBOSE=$7 + -+// nv_drm_update_drm_driver_features(); ++ echo "int cc_sanity_check(void) { ++ return 0; ++ }" > conftest$$.c + -+ /* Enumerate NVIDIA GPUs */ ++ $CC -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c + -+ gpu_info = nv_drm_calloc(NV_MAX_GPUS, sizeof(*gpu_info)); ++ if [ ! -f conftest$$.o ]; then ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo ""; ++ fi ++ if [ "$CC" != "cc" ]; then ++ echo "The C compiler '$CC' does not appear to be able to" ++ echo "create object files. Please make sure you have " ++ echo "your Linux distribution's libc development package" ++ echo "installed and that '$CC' is a valid C compiler"; ++ echo "name." ++ else ++ echo "The C compiler '$CC' does not appear to be able to" ++ echo "create executables. Please make sure you have " ++ echo "your Linux distribution's gcc and libc development" ++ echo "packages installed." ++ fi ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo ""; ++ echo "*** Failed CC sanity check. Bailing out! ***"; ++ echo ""; ++ fi ++ exit 1 ++ else ++ rm -f conftest$$.o ++ exit 0 ++ fi ++ ;; ++ ++ cc_version_check) ++ # ++ # Verify that the same compiler major and minor version is ++ # used for the kernel and kernel module. ++ # ++ # Some gcc version strings that have proven problematic for parsing ++ # in the past: ++ # ++ # gcc.real (GCC) 3.3 (Debian) ++ # gcc-Version 3.3 (Debian) ++ # gcc (GCC) 3.1.1 20020606 (Debian prerelease) ++ # version gcc 3.2.3 ++ # ++ VERBOSE=$7 ++ ++ kernel_compile_h=$OUTPUT/include/generated/compile.h ++ ++ if [ ! -f ${kernel_compile_h} ]; then ++ # The kernel's compile.h file is not present, so there ++ # isn't a convenient way to identify the compiler version ++ # used to build the kernel. ++ IGNORE_CC_MISMATCH=1 ++ fi ++ ++ if [ -n "$IGNORE_CC_MISMATCH" ]; then ++ exit 0 ++ fi ++ ++ kernel_cc_string=`cat ${kernel_compile_h} | \ ++ grep LINUX_COMPILER | cut -f 2 -d '"'` ++ ++ kernel_cc_version=`echo ${kernel_cc_string} | grep -o '[0-9]\+\.[0-9]\+' | head -n 1` ++ kernel_cc_major=`echo ${kernel_cc_version} | cut -d '.' -f 1` ++ kernel_cc_minor=`echo ${kernel_cc_version} | cut -d '.' -f 2` ++ ++ echo " ++ #if (__GNUC__ != ${kernel_cc_major}) || (__GNUC_MINOR__ != ${kernel_cc_minor}) ++ #error \"cc version mismatch\" ++ #endif ++ " > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ rm -f conftest$$.o ++ exit 0; ++ else ++ # ++ # The gcc version check failed ++ # + -+ if (gpu_info == NULL) { -+ ret = -ENOMEM; ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo ""; ++ echo "Compiler version check failed:"; ++ echo ""; ++ echo "The major and minor number of the compiler used to"; ++ echo "compile the kernel:"; ++ echo ""; ++ echo "${kernel_cc_string}"; ++ echo ""; ++ echo "does not match the compiler used here:"; ++ echo ""; ++ $CC --version ++ echo ""; ++ echo "It is recommended to set the CC environment variable"; ++ echo "to the compiler that was used to compile the kernel."; ++ echo "" ++ echo "The compiler version check can be disabled by setting"; ++ echo "the IGNORE_CC_MISMATCH environment variable to \"1\"."; ++ echo "However, mixing compiler versions between the kernel"; ++ echo "and kernel modules can result in subtle bugs that are"; ++ echo "difficult to diagnose."; ++ echo ""; ++ echo "*** Failed CC version check. Bailing out! ***"; ++ echo ""; ++ elif [ "$VERBOSE" = "just_msg" ]; then ++ echo "The kernel was built with ${kernel_cc_string}, but the" \ ++ "current compiler version is `$CC --version | head -n 1`."; ++ fi ++ exit 1; ++ fi ++ ;; ++ ++ get_uname) ++ # ++ # Print UTS_RELEASE from the kernel sources, if the kernel header ++ # file ../linux/version.h or ../linux/utsrelease.h exists. If ++ # neither header file is found, but a Makefile is found, extract ++ # PATCHLEVEL and SUBLEVEL, and use them to build the kernel ++ # release name. ++ # ++ # If no source file is found, or if an error occurred, return the ++ # output of `uname -r`. ++ # ++ RET=1 ++ DIRS="generated linux" ++ FILE="" ++ ++ for DIR in $DIRS; do ++ if [ -f $HEADERS/$DIR/utsrelease.h ]; then ++ FILE="$HEADERS/$DIR/utsrelease.h" ++ break ++ elif [ -f $OUTPUT/include/$DIR/utsrelease.h ]; then ++ FILE="$OUTPUT/include/$DIR/utsrelease.h" ++ break ++ fi ++ done + -+ NV_DRM_LOG_ERR("Failed to allocate gpu ids arrays"); -+ goto done; -+ } ++ if [ -z "$FILE" ]; then ++ if [ -f $HEADERS/linux/version.h ]; then ++ FILE="$HEADERS/linux/version.h" ++ elif [ -f $OUTPUT/include/linux/version.h ]; then ++ FILE="$OUTPUT/include/linux/version.h" ++ fi ++ fi + -+ gpu_count = nvKmsenumerateGpus(gpu_info, driver, pdriver); -+// gpu_count = nvKms->enumerateGpus(gpu_info); ++ if [ -n "$FILE" ]; then ++ # ++ # We are either looking at a configured kernel source tree ++ # or at headers shipped for a specific kernel. Determine ++ # the kernel version using a CPP check. ++ # ++ VERSION=`echo "UTS_RELEASE" | $CC - -E -P -include $FILE 2>&1` + -+ if (gpu_count == 0) { -+ NV_DRM_LOG_INFO("Not found NVIDIA GPUs"); -+ goto done; ++ if [ "$?" = "0" -a "VERSION" != "UTS_RELEASE" ]; then ++ echo "$VERSION" ++ RET=0 ++ fi ++ else ++ # ++ # If none of the kernel headers ar found, but a Makefile is, ++ # extract PATCHLEVEL and SUBLEVEL and use them to find ++ # the kernel version. ++ # ++ MAKEFILE=$HEADERS/../Makefile ++ ++ if [ -f $MAKEFILE ]; then ++ # ++ # This source tree is not configured, but includes ++ # the top-level Makefile. ++ # ++ PATCHLEVEL=$(grep "^PATCHLEVEL =" $MAKEFILE | cut -d " " -f 3) ++ SUBLEVEL=$(grep "^SUBLEVEL =" $MAKEFILE | cut -d " " -f 3) ++ ++ if [ -n "$PATCHLEVEL" -a -n "$SUBLEVEL" ]; then ++ echo 2.$PATCHLEVEL.$SUBLEVEL ++ RET=0 ++ fi ++ fi ++ fi ++ ++ if [ "$RET" != "0" ]; then ++ uname -r ++ exit 1 ++ else ++ exit 0 ++ fi ++ ;; ++ ++ xen_sanity_check) ++ # ++ # Check if the target kernel is a Xen kernel. If so, exit, since ++ # the RM doesn't currently support Xen. ++ # ++ VERBOSE=$7 ++ ++ if [ -n "$IGNORE_XEN_PRESENCE" -o -n "$VGX_BUILD" ]; then ++ exit 0 ++ fi ++ ++ test_xen ++ ++ if [ "$XEN_PRESENT" != "0" ]; then ++ echo "The kernel you are installing for is a Xen kernel!"; ++ echo ""; ++ echo "The NVIDIA driver does not currently support Xen kernels. If "; ++ echo "you are using a stock distribution kernel, please install "; ++ echo "a variant of this kernel without Xen support; if this is a "; ++ echo "custom kernel, please install a standard Linux kernel. Then "; ++ echo "try installing the NVIDIA kernel module again."; ++ echo ""; ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo "*** Failed Xen sanity check. Bailing out! ***"; ++ echo ""; ++ fi ++ exit 1 ++ else ++ exit 0 ++ fi ++ ;; ++ ++ preempt_rt_sanity_check) ++ # ++ # Check if the target kernel has the PREEMPT_RT patch set applied. If ++ # so, exit, since the RM doesn't support this configuration. ++ # ++ VERBOSE=$7 ++ ++ if [ -n "$IGNORE_PREEMPT_RT_PRESENCE" ]; then ++ exit 0 ++ fi ++ ++ if test_configuration_option CONFIG_PREEMPT_RT; then ++ PREEMPT_RT_PRESENT=1 ++ elif test_configuration_option CONFIG_PREEMPT_RT_FULL; then ++ PREEMPT_RT_PRESENT=1 ++ fi ++ ++ if [ "$PREEMPT_RT_PRESENT" != "0" ]; then ++ echo "The kernel you are installing for is a PREEMPT_RT kernel!"; ++ echo ""; ++ echo "The NVIDIA driver does not support real-time kernels. If you "; ++ echo "are using a stock distribution kernel, please install "; ++ echo "a variant of this kernel that does not have the PREEMPT_RT "; ++ echo "patch set applied; if this is a custom kernel, please "; ++ echo "install a standard Linux kernel. Then try installing the "; ++ echo "NVIDIA kernel module again."; ++ echo ""; ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo "*** Failed PREEMPT_RT sanity check. Bailing out! ***"; ++ echo ""; ++ fi ++ exit 1 ++ else ++ exit 0 ++ fi ++ ;; ++ ++ patch_check) ++ # ++ # Check for any "official" patches that may have been applied and ++ # construct a description table for reporting purposes. ++ # ++ PATCHES="" ++ ++ for PATCH in patch-*.h; do ++ if [ -f $PATCH ]; then ++ echo "#include \"$PATCH\"" ++ PATCHES="$PATCHES "`echo $PATCH | sed -s 's/patch-\(.*\)\.h/\1/'` ++ fi ++ done ++ ++ echo "static struct { ++ const char *short_description; ++ const char *description; ++ } __nv_patches[] = {" ++ for i in $PATCHES; do ++ echo "{ \"$i\", NV_PATCH_${i}_DESCRIPTION }," ++ done ++ echo "{ NULL, NULL } };" ++ ++ exit 0 ++ ;; ++ ++ compile_tests) ++ # ++ # Run a series of compile tests to determine the set of interfaces ++ # and features available in the target kernel. ++ # ++ shift 6 ++ ++ CFLAGS=$1 ++ shift ++ ++ for i in $*; do compile_test $i; done ++ ++ exit 0 ++ ;; ++ ++ dom0_sanity_check) ++ # ++ # Determine whether running in DOM0. ++ # ++ VERBOSE=$7 ++ ++ if [ -n "$VGX_BUILD" ]; then ++ if [ -f /proc/xen/capabilities ]; then ++ if [ "`cat /proc/xen/capabilities`" == "control_d" ]; then ++ exit 0 ++ fi ++ else ++ echo "The kernel is not running in DOM0."; ++ echo ""; ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo "*** Failed DOM0 sanity check. Bailing out! ***"; ++ echo ""; ++ fi ++ fi ++ exit 1 ++ fi ++ ;; ++ vgpu_kvm_sanity_check) ++ # ++ # Determine whether we are running a vGPU on KVM host. ++ # ++ VERBOSE=$7 ++ iommu=CONFIG_VFIO_IOMMU_TYPE1 ++ mdev=CONFIG_VFIO_MDEV_DEVICE ++ kvm=CONFIG_KVM_VFIO ++ ++ if [ -n "$VGX_KVM_BUILD" ]; then ++ if (test_configuration_option ${iommu} || test_configuration_option ${iommu}_MODULE) && ++ (test_configuration_option ${mdev} || test_configuration_option ${mdev}_MODULE) && ++ (test_configuration_option ${kvm} || test_configuration_option ${kvm}_MODULE); then ++ exit 0 ++ else ++ echo "The kernel is not running a vGPU on KVM host."; ++ echo ""; ++ if [ "$VERBOSE" = "full_output" ]; then ++ echo "*** Failed vGPU on KVM sanity check. Bailing out! ***"; ++ echo ""; ++ fi ++ fi ++ exit 1 ++ else ++ exit 0 ++ fi ++ ;; ++ test_configuration_option) ++ # ++ # Check to see if the given config option is set. ++ # ++ OPTION=$7 ++ ++ test_configuration_option $OPTION ++ exit $? ++ ;; ++ ++ get_configuration_option) ++ # ++ # Get the value of the given config option. ++ # ++ OPTION=$7 ++ ++ get_configuration_option $OPTION ++ exit $? ++ ;; ++ ++ ++ guess_module_signing_hash) ++ # ++ # Determine the best cryptographic hash to use for module signing, ++ # to the extent that is possible. ++ # ++ ++ HASH=$(get_configuration_option CONFIG_MODULE_SIG_HASH) ++ ++ if [ $? -eq 0 ] && [ -n $HASH ]; then ++ echo $HASH ++ exit 0 ++ else ++ for SHA in 512 384 256 224 1; do ++ if test_configuration_option CONFIG_MODULE_SIG_SHA$SHA; then ++ echo sha$SHA ++ exit 0 ++ fi ++ done ++ fi ++ exit 1 ++ ;; ++ ++ ++ test_kernel_headers) ++ # ++ # Check for the availability of certain kernel headers ++ # ++ ++ test_headers ++ exit $? ++ ;; ++ ++ ++ build_cflags) ++ # ++ # Generate CFLAGS for use in the compile tests ++ # ++ ++ build_cflags ++ echo $CFLAGS ++ exit 0 ++ ;; ++ ++esac +diff -Naur a/kernel/nv-acpi.c b/kernel/nv-acpi.c +--- a/kernel/nv-acpi.c 2023-03-04 13:26:40.796675128 +0100 ++++ b/kernel/nv-acpi.c 2023-03-04 13:59:14.171648867 +0100 +@@ -180,6 +180,53 @@ + return 0; + } + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0) ++static struct nv_acpi_add_enumerated_data { ++ nv_acpi_t *object; ++ int *counter; ++}; ++static int nv_acpi_add_enumerated(struct acpi_device *dev, void *data) ++{ ++ struct nv_acpi_add_enumerated_data *rcvd_data = data; ++ nv_acpi_t *pNvAcpiObject = rcvd_data->object; ++ int *device_counter = rcvd_data->counter; ++ acpi_status status = -1; ++ nv_acpi_integer_t device_id = 0; ++ if (!dev) ++ return 0; ++ if (*device_counter == NV_MAXNUM_DISPLAY_DEVICES) { ++ nv_printf(NV_DBG_ERRORS, ++ "NVRM: nv_acpi_add: Total number of devices cannot exceed %d\n", ++ NV_MAXNUM_DISPLAY_DEVICES); ++ return 1; + } -+ -+ WARN_ON(gpu_count > NV_MAX_GPUS); -+ -+ /* Register DRM device for each NVIDIA GPU */ -+ -+ for (i = 0; i < gpu_count; i++) { -+ nv_drm_register_drm_device(&gpu_info[i]); ++ status = ++ acpi_evaluate_integer(dev->handle, "_ADR", NULL, &device_id); ++ if (ACPI_FAILURE(status)) ++ /* Couldnt query device_id for this device */ ++ return 0; ++ ++ device_id = (device_id & 0xffff); ++ ++ if ((device_id != 0x100) && /* Not a known CRT device-id */ ++ (device_id != 0x200) && /* Not a known TV device-id */ ++ (device_id != 0x0110) && (device_id != 0x0118) && (device_id != 0x0400) && /* Not an LCD*/ ++ (device_id != 0x0111) && (device_id != 0x0120) && (device_id != 0x0300)) /* Not a known DVI device-id */ ++ { ++ /* This isnt a known device Id. ++ Do default switching on this system. */ ++ pNvAcpiObject->default_display_mask = 1; ++ return 1; + } + -+done: -+ -+ nv_drm_free(gpu_info); -+ -+ return ret; -+} -+ -+/* -+ * Unregister all NVIDIA DRM devices. -+ */ -+void nv_drm_remove_devices(void) -+{ -+ while (dev_list != NULL) { -+ struct nv_drm_device *next = dev_list->next; -+ -+ drm_dev_unregister(dev_list->dev); -+ nv_drm_dev_free(dev_list->dev); ++ pNvAcpiObject->pNvVideo[*device_counter].dev_id = device_id; ++ pNvAcpiObject->pNvVideo[*device_counter].dev_handle = dev->handle; + -+ nv_drm_free(dev_list); -+ -+ dev_list = next; -+ } ++ (*device_counter)++; ++ return 0; +} ++#endif + - #endif /* defined(NV_DRM_AVAILABLE) */ - - int __init nv_drm_init( -@@ -211,7 +504,7 @@ - { - int ret = 0; - #if defined(NV_DRM_AVAILABLE) -- ret = nv_drm_pci_init(&nv_drm_driver, pci_driver); -+ ret = nv_drm_probe_devices(&nv_drm_driver, pci_driver); - #endif - return ret; - } -@@ -221,7 +514,7 @@ - ) + static int nv_acpi_add(struct acpi_device *device) { - #if defined(NV_DRM_AVAILABLE) -- nv_drm_pci_exit(&nv_drm_driver, pci_driver); -+ nv_drm_remove_devices(); - #endif - } - -@@ -282,9 +575,15 @@ - goto done; - } - --#if defined(NV_DRM_GEM_OBJECT_PUT_UNLOCKED_PRESENT) -+#if defined(NV_DRM_GEM_OBJECT_GET_PRESENT) -+ -+#if defined(NV_DRM_GEM_OBJECT_PUT_UNLOCK_PRESENT) - drm_gem_object_put_unlocked(&nv_obj->base); - #else -+ drm_gem_object_put(&nv_obj->base); + /* +@@ -192,9 +239,11 @@ + union acpi_object control_argument_0 = { ACPI_TYPE_INTEGER }; + struct acpi_object_list control_argument_list = { 0, NULL }; + nv_stack_t *sp = NULL; ++#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 0, 0) ++ struct list_head *node, *next; + nv_acpi_integer_t device_id = 0; +#endif -+ -+#else - drm_gem_object_unreference_unlocked(&nv_obj->base); - #endif - -diff -Naur a/kernel/nv-frontend.c b/kernel/nv-frontend.c ---- a/kernel/nv-frontend.c 2022-10-16 09:28:09.692227714 +0200 -+++ b/kernel/nv-frontend.c 2022-10-16 09:18:55.847854785 +0200 -@@ -8,6 +8,7 @@ - * _NVRM_COPYRIGHT_END_ - */ - -+#include "conftest.h" - #include "nv-misc.h" - #include "os-interface.h" - #include "nv-linux.h" -@@ -15,7 +16,7 @@ - #include "nv-frontend.h" - - #if defined(MODULE_LICENSE) --MODULE_LICENSE("NVIDIA"); -+MODULE_LICENSE("GPL"); - #endif - #if defined(MODULE_INFO) - MODULE_INFO(supported, "external"); -@@ -377,7 +378,7 @@ - #if (NV_BUILD_MODULE_INSTANCES != 0) - #if defined(CONFIG_PROC_FS) - if ((nv_num_instances == 0) && (nv_proc_topdir != NULL)) -- NV_REMOVE_PROCE_ENTRY(nv_proc_topdir); -+ NV_REMOVE_PROC_ENTRY(nv_proc_topdir); - #endif - #else - nvidia_exit_module(); -diff -Naur a/kernel/nv.h b/kernel/nv.h ---- a/kernel/nv.h 2022-10-16 09:28:09.740226618 +0200 -+++ b/kernel/nv.h 2022-08-28 09:42:35.549184106 +0200 -@@ -13,7 +13,7 @@ - #define _NV_H_ - - #include <nvtypes.h> --#include <stdarg.h> -+#include "nv_stdarg.h" - - #if !defined(NV_MIN) - #define NV_MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b)) -diff -Naur a/kernel/nvidia-drm-conftest.h b/kernel/nvidia-drm-conftest.h ---- a/kernel/nvidia-drm-conftest.h 2022-10-16 09:28:09.782225660 +0200 -+++ b/kernel/nvidia-drm-conftest.h 2022-08-28 09:42:35.549184106 +0200 -@@ -54,7 +54,7 @@ - - #endif - --#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ) || \ -+#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ) && \ - defined(NV_DRM_GEM_OBJECT_HAS_RESV) - #define NV_DRM_FENCE_AVAILABLE - #else -diff -Naur a/kernel/nvidia-drm-gem.c b/kernel/nvidia-drm-gem.c ---- a/kernel/nvidia-drm-gem.c 2022-10-16 09:28:09.784225614 +0200 -+++ b/kernel/nvidia-drm-gem.c 2022-08-28 09:42:35.549184106 +0200 -@@ -26,10 +26,10 @@ - - #include "nvidia-drm-priv.h" - #include "nvidia-drm-ioctl.h" --#include "nvidia-drm-prime-fence.h" -+// #include "nvidia-drm-prime-fence.h" - #include "nvidia-drm-gem.h" - #include "nvidia-dma-resv-helper.h" --#include "nvidia-drm-gem-nvkms-memory.h" -+// #include "nvidia-drm-gem-nvkms-memory.h" - - #if defined(NV_DRM_DRM_PRIME_H_PRESENT) - #include <drm/drm_prime.h> -@@ -99,9 +99,9 @@ - .vunmap = nv_drm_gem_prime_vunmap, - #endif - --#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -- .vm_ops = &nv_drm_gem_vma_ops, --#endif -+// #if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -+// .vm_ops = &nv_drm_gem_vma_ops, -+// #endif - - #endif - }; -diff -Naur a/kernel/nvidia-drm-helper.c b/kernel/nvidia-drm-helper.c ---- a/kernel/nvidia-drm-helper.c 2022-10-16 09:28:09.785225591 +0200 -+++ b/kernel/nvidia-drm-helper.c 2022-10-16 09:23:22.593780123 +0200 -@@ -29,7 +29,7 @@ - - #include "nvidia-drm-helper.h" - --#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -+#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) && FALSE - - #if defined(NV_DRM_DRMP_H_PRESENT) - #include <drm/drmP.h> -diff -Naur a/kernel/nvidia-drm-linux.c b/kernel/nvidia-drm-linux.c ---- a/kernel/nvidia-drm-linux.c 2022-10-16 09:28:09.786225568 +0200 -+++ b/kernel/nvidia-drm-linux.c 2022-08-28 09:42:35.549184106 +0200 -@@ -25,7 +25,6 @@ - #include <linux/err.h> + int device_counter = 0; +- acpi_handle handle = NULL; - #include "nvidia-drm-os-interface.h" --#include "nvidia-drm.h" + NV_KMEM_CACHE_ALLOC_STACK(sp); + if (sp == NULL) +@@ -222,12 +271,14 @@ - #include "nvidia-drm-conftest.h" + // grab handles to all the important nodes representing devices -@@ -161,25 +160,3 @@ - * Linux loading support code. - *************************************************************************/ - --static int __init nv_linux_drm_init(void) --{ -- return nv_drm_init(); --} -- --static void __exit nv_linux_drm_exit(void) --{ -- nv_drm_exit(); --} -- --module_init(nv_linux_drm_init); --module_exit(nv_linux_drm_exit); -- --#if defined(MODULE_LICENSE) -- MODULE_LICENSE("MIT"); --#endif --#if defined(MODULE_INFO) -- MODULE_INFO(supported, "external"); --#endif --#if defined(MODULE_VERSION) -- MODULE_VERSION(NV_VERSION_STRING); --#endif -diff -Naur a/kernel/nvidia-modules-common.mk b/kernel/nvidia-modules-common.mk ---- a/kernel/nvidia-modules-common.mk 2022-10-16 09:28:09.740226618 +0200 -+++ b/kernel/nvidia-modules-common.mk 2022-08-28 09:42:35.550184084 +0200 -@@ -149,10 +149,10 @@ - CONFTEST_HEADERS := $(obj)/conftest.h $(CONFTEST_COMPILE_TEST_HEADERS) \ - $(obj)/conftest/patches.h - --$(obj)/conftest.h $(CONFTEST_COMPILE_TEST_HEADERS): conftest-compile-test -+# $(obj)/conftest.h $(CONFTEST_COMPILE_TEST_HEADERS): conftest-compile-test - --conftest-compile-test: $(src)/conftest.sh -- @if ! $(CONFTEST) compile_tests $(COMPILE_TESTS); then exit 1; fi -+# conftest-compile-test: $(src)/conftest.sh -+# @if ! $(CONFTEST) compile_tests $(COMPILE_TESTS); then exit 1; fi - - $(obj)/conftest/patches.h: - @if ! $(CONFTEST) patch_check; then exit 1; fi -@@ -222,6 +222,7 @@ - define BUILD_MODULE_RULE - $(1): build-sanity-checks $(3) - @echo "NVIDIA: calling KBUILD..."; \ -+ touch .nv-kernel.o.cmd; \ - $$(MAKE) "CC=$$(CC)" NV_MODULE_SUFFIX=$$(strip $(2)) $$(KBUILD_PARAMS) modules; \ - echo "NVIDIA: left KBUILD."; \ - if ! [ -f $(1) ]; then \ -@@ -317,7 +318,7 @@ - @$(RM) -f build-in.o nv-linux*.o *.d .*.cmd .*.flags - @$(RM) -f $(MODULE_NAME)*.o $(MODULE_NAME)*.ko* - @$(RM) -f $(MODULE_NAME)*.mod* $(VERSION_HEADER) *~ -- @$(RM) -f conftest*.c conftest.h -+ @$(RM) -f conftest*.c - @$(RM) -rf conftest - @$(RM) -rf Module*.symvers .tmp_versions modules.order +- do ++#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 0, 0) ++ list_for_each_safe(node, next, &device->children) + { +- status = acpi_get_next_object(ACPI_TYPE_DEVICE, device->handle, +- handle, &handle); +- if (ACPI_FAILURE(status) || (handle == NULL)) +- break; ++ struct acpi_device *dev = ++ list_entry(node, struct acpi_device, node); ++ ++ if (!dev) ++ continue; -diff -Naur a/kernel/nv-linux.h b/kernel/nv-linux.h ---- a/kernel/nv-linux.h 2022-10-16 09:28:09.693227691 +0200 -+++ b/kernel/nv-linux.h 2022-08-28 09:42:35.545184193 +0200 -@@ -119,12 +119,15 @@ - #include <asm/tlbflush.h> /* flush_tlb(), flush_tlb_all() */ - #include <linux/cpu.h> /* CPU hotplug support */ - #endif --#include <asm/kmap_types.h> /* page table entry lookup */ -+#if defined(NV_ASM_KMAP_TYPES_H_PRESENT) -+ #include <asm/kmap_types.h> /* page table entry lookup */ -+#endif + if (device_counter == NV_MAXNUM_DISPLAY_DEVICES) + { +@@ -238,7 +289,7 @@ + } - #include <linux/pci.h> /* pci_find_class, etc */ - #include <linux/interrupt.h> /* tasklets, interrupt helpers */ - #include <linux/timer.h> -- -+#include <linux/file.h> /* fget(), fput() -+*/ - #include <asm/div64.h> /* do_div() */ - #if defined(NV_ASM_SYSTEM_H_PRESENT) - #include <asm/system.h> /* cli, sli, save_flags */ -@@ -134,7 +137,7 @@ - #include <asm/page.h> /* PAGE_OFFSET */ - #include <asm/pgtable.h> /* pte bit definitions */ + status = +- acpi_evaluate_integer(handle, "_ADR", NULL, &device_id); ++ acpi_evaluate_integer(dev->handle, "_ADR", NULL, &device_id); + if (ACPI_FAILURE(status)) + /* Couldnt query device_id for this device */ + continue; +@@ -257,11 +308,18 @@ + } --#if defined(NVCPU_X86_64) && !defined(HAVE_COMPAT_IOCTL) -+#if defined(NVCPU_X86_64) && !defined(NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL) - #include <linux/syscalls.h> /* sys_ioctl() */ - #include <linux/ioctl32.h> /* register_ioctl32_conversion() */ - #endif -@@ -255,7 +258,8 @@ - * NVIDIA graphics driver has no way of knowing and is unlikely - * to work correctly. - */ --#if defined(CONFIG_XEN) && !defined(CONFIG_PARAVIRT) -+#if defined(CONFIG_XEN) && !defined(CONFIG_PARAVIRT) && \ -+ !defined(NVCPU_ARM) - #include <asm/maddr.h> - #include <xen/interface/memory.h> - #define NV_XEN_SUPPORT_FULLY_VIRTUALIZED_KERNEL -@@ -669,11 +673,19 @@ - # define KM_FREE_RECORD(a,b,c) - #endif + pNvAcpiObject->pNvVideo[device_counter].dev_id = device_id; +- pNvAcpiObject->pNvVideo[device_counter].dev_handle = handle; ++ pNvAcpiObject->pNvVideo[device_counter].dev_handle = dev->handle; + + device_counter++; -+#if !defined(NV_VMALLOC_HAS_PGPROT_T_ARG) -+#define NV_VMALLOC(ptr, size) \ -+ { \ -+ (ptr) = __vmalloc(size, GFP_KERNEL); \ -+ VM_ALLOC_RECORD(ptr, size, "vm_vmalloc"); \ +- } while (handle != NULL); + } +#else - #define NV_VMALLOC(ptr, size) \ - { \ - (ptr) = __vmalloc(size, GFP_KERNEL, PAGE_KERNEL); \ - VM_ALLOC_RECORD(ptr, size, "vm_vmalloc"); \ - } -+#endif - - #define NV_VFREE(ptr, size) \ - { \ -@@ -688,11 +700,16 @@ - VM_ALLOC_RECORD(ptr, size, "vm_ioremap"); \ - } - -+#if defined(NV_IOREMAP_NOCACHE_PRESENT) - #define NV_IOREMAP_NOCACHE(ptr, physaddr, size) \ - { \ - (ptr) = ioremap_nocache(physaddr, size); \ - VM_ALLOC_RECORD(ptr, size, "vm_ioremap_nocache"); \ - } -+#else -+#define NV_IOREMAP_NOCACHE(ptr, physaddr, size) \ -+ NV_IOREMAP(ptr, physaddr, size) ++ struct nv_acpi_add_enumerated_data data = { ++ .object = pNvAcpiObject, ++ .counter = &device_counter, ++ }; ++ acpi_dev_for_each_child(device, nv_acpi_add_enumerated, &data); +#endif - #if defined(NV_IOREMAP_CACHE_PRESENT) - #define NV_IOREMAP_CACHE(ptr, physaddr, size) \ -@@ -774,6 +791,17 @@ - #error "NV_KMEM_CACHE_CREATE() undefined (kmem_cache_create() unavailable)!" - #endif + // arg 0, bits 1:0, 0 = enable events + control_argument_0.integer.type = ACPI_TYPE_INTEGER; +@@ -1196,6 +1254,31 @@ + return status; + } -+#if defined(NV_KMEM_CACHE_CREATE_USERCOPY_PRESENT) -+#define NV_KMEM_CACHE_CREATE_USERCOPY(kmem_cache, name, type) \ -+ { \ -+ kmem_cache = kmem_cache_create_usercopy(name, sizeof(type), \ -+ 0, 0, 0, sizeof(type), NULL); \ ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0) ++static int nv_acpi_ddc_method_enumerated(struct acpi_device *dev, void *data) ++{ ++ acpi_handle *lcd_dev_handle = data; ++ acpi_status status; ++ nv_acpi_integer_t device_id = 0; ++ if (!dev) ++ return 0; ++ status = acpi_evaluate_integer(dev->handle, "_ADR", NULL, &device_id); ++ if (ACPI_FAILURE(status)) ++ /* Couldnt query device_id for this device */ ++ return 0; ++ ++ device_id = (device_id & 0xffff); ++ ++ if ((device_id == 0x0110) || (device_id == 0x0118) || (device_id == 0x0400)) /* Only for an LCD*/ ++ { ++ *lcd_dev_handle = dev->handle; ++ nv_printf(NV_DBG_INFO, "NVRM: %s Found LCD: %x\n", __FUNCTION__, device_id); ++ return 1; + } -+#else -+#define NV_KMEM_CACHE_CREATE_USERCOPY(kmem_cache, name, type) \ -+ NV_KMEM_CACHE_CREATE(kmem_cache, name, type) ++ return 0; ++} +#endif + - #define NV_KMEM_CACHE_ALLOC(ptr, kmem_cache, type) \ - { \ - (ptr) = kmem_cache_alloc(kmem_cache, GFP_KERNEL); \ -@@ -1971,6 +1999,19 @@ - }) - #endif - -+#if defined(NV_PROC_OPS_PRESENT) -+#define NV_CREATE_PROC_FILE(filename,parent,__name,__data) \ -+ ({ \ -+ struct proc_dir_entry *__entry; \ -+ int mode = (S_IFREG | S_IRUGO); \ -+ const struct proc_ops *fops = &nv_procfs_##__name##_fops; \ -+ if (fops->proc_write != 0) \ -+ mode |= S_IWUSR; \ -+ __entry = NV_CREATE_PROC_ENTRY(filename, mode, parent, fops, \ -+ __data); \ -+ __entry; \ -+ }) -+#else - #define NV_CREATE_PROC_FILE(filename,parent,__name,__data) \ - ({ \ - struct proc_dir_entry *__entry; \ -@@ -1982,6 +2023,7 @@ - __data); \ - __entry; \ - }) -+#endif - /* - * proc_mkdir_mode exists in Linux 2.6.9, but isn't exported until Linux 3.0. -@@ -2010,9 +2052,11 @@ - }) - - #if defined(NV_PDE_DATA_PRESENT) --# define NV_PDE_DATA(inode) PDE_DATA(inode) -+#define NV_PDE_DATA(inode) pde_data(inode) -+#elif defined(NV_PDE_DATA_UPPER_CASE_PRESENT) -+#define NV_PDE_DATA(inode) PDE_DATA(inode) - #else --# define NV_PDE_DATA(inode) PDE(inode)->data -+#define NV_PDE_DATA(inode) PDE(inode)->data - #endif - - #if defined(NV_PROC_REMOVE_PRESENT) -@@ -2023,6 +2067,24 @@ - remove_proc_entry(entry->name, entry->parent); - #endif - -+#if defined(NV_PROC_OPS_PRESENT) -+#define NV_DEFINE_PROCFS_SINGLE_FILE(__name) \ -+ static int nv_procfs_open_##__name( \ -+ struct inode *inode, \ -+ struct file *filep \ -+ ) \ -+ { \ -+ return single_open(filep, nv_procfs_read_##__name, \ -+ NV_PDE_DATA(inode)); \ -+ } \ -+ \ -+ static const struct proc_ops nv_procfs_##__name##_fops = { \ -+ .proc_open = nv_procfs_open_##__name, \ -+ .proc_read = seq_read, \ -+ .proc_lseek = seq_lseek, \ -+ .proc_release = single_release, \ -+ }; -+#else - #define NV_DEFINE_PROCFS_SINGLE_FILE(__name) \ - static int nv_procfs_open_##__name( \ - struct inode *inode, \ -@@ -2040,6 +2102,7 @@ - .llseek = seq_lseek, \ - .release = single_release, \ - }; -+#endif - - #endif /* CONFIG_PROC_FS */ - -@@ -2075,157 +2138,4 @@ - #endif - } - --/* get_user_pages -- * -- * The 8-argument version of get_user_pages was deprecated by commit -- * (2016 Feb 12: cde70140fed8429acf7a14e2e2cbd3e329036653)for the non-remote case -- * (calling get_user_pages with current and current->mm). -- * -- * Completely moved to the 6 argument version of get_user_pages - -- * 2016 Apr 4: c12d2da56d0e07d230968ee2305aaa86b93a6832 -- * -- * write and force parameters were replaced with gup_flags by - -- * 2016 Oct 12: 768ae309a96103ed02eb1e111e838c87854d8b51 -- * -- * A 7-argument version of get_user_pages was introduced into linux-4.4.y by -- * commit 8e50b8b07f462ab4b91bc1491b1c91bd75e4ad40 which cherry-pciked the -- * replacement of the write and force parameters with gup_flags -- * -- */ -- --#if defined(NV_GET_USER_PAGES_HAS_TASK_STRUCT) -- #if defined(NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS) -- #define NV_GET_USER_PAGES(start, nr_pages, write, force, pages, vmas) \ -- get_user_pages(current, current->mm, start, nr_pages, write, force, pages, vmas) -- #else -- #include <linux/mm.h> -- #include <linux/sched.h> -- -- static inline long NV_GET_USER_PAGES(unsigned long start, -- unsigned long nr_pages, -- int write, -- int force, -- struct page **pages, -- struct vm_area_struct **vmas) -- { -- unsigned int flags = 0; -- -- if (write) -- flags |= FOLL_WRITE; -- if (force) -- flags |= FOLL_FORCE; -- -- return get_user_pages(current, current->mm, start, nr_pages, flags, -- pages, vmas); -- } -- -- #endif --#else -- #if defined(NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS) -- #define NV_GET_USER_PAGES get_user_pages -- #else -- #include <linux/mm.h> -- -- static inline long NV_GET_USER_PAGES(unsigned long start, -- unsigned long nr_pages, -- int write, -- int force, -- struct page **pages, -- struct vm_area_struct **vmas) -- { -- unsigned int flags = 0; -- -- if (write) -- flags |= FOLL_WRITE; -- if (force) -- flags |= FOLL_FORCE; -- -- return get_user_pages(start, nr_pages, flags, pages, vmas); -- } -- #endif --#endif -- --/* get_user_pages_remote() was added by: -- * 2016 Feb 12: 1e9877902dc7e11d2be038371c6fbf2dfcd469d7 -- * -- * The very next commit (cde70140fed8429acf7a14e2e2cbd3e329036653) -- * deprecated the 8-argument version of get_user_pages for the -- * non-remote case (calling get_user_pages with current and current->mm). -- * -- * The guidelines are: call NV_GET_USER_PAGES_REMOTE if you need the 8-argument -- * version that uses something other than current and current->mm. Use -- * NV_GET_USER_PAGES if you are refering to current and current->mm. -- * -- * Note that get_user_pages_remote() requires the caller to hold a reference on -- * the task_struct (if non-NULL) and the mm_struct. This will always be true -- * when using current and current->mm. If the kernel passes the driver a vma -- * via driver callback, the kernel holds a reference on vma->vm_mm over that -- * callback. -- * -- * get_user_pages_remote() added 'locked' parameter -- * 2016 Dec 14:5b56d49fc31dbb0487e14ead790fc81ca9fb2c99 -- */ -- --#if defined(NV_GET_USER_PAGES_REMOTE_PRESENT) -- #if defined (NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS) -- #define NV_GET_USER_PAGES_REMOTE get_user_pages_remote -- #else -- static inline long NV_GET_USER_PAGES_REMOTE(struct task_struct *tsk, -- struct mm_struct *mm, -- unsigned long start, -- unsigned long nr_pages, -- int write, -- int force, -- struct page **pages, -- struct vm_area_struct **vmas) -- { -- unsigned int flags = 0; -- -- if (write) -- flags |= FOLL_WRITE; -- if (force) -- flags |= FOLL_FORCE; -- -- #if defined(NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG) -- -- return get_user_pages_remote(tsk, mm, start, nr_pages, flags, -- pages, vmas, NULL); -- -- #else -- -- return get_user_pages_remote(tsk, mm, start, nr_pages, flags, -- pages, vmas); -- -- #endif -- -- } -- #endif --#else -- #if defined(NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS) -- #define NV_GET_USER_PAGES_REMOTE NV_GET_USER_PAGES -- #else -- #include <linux/mm.h> -- #include <linux/sched.h> -- -- static inline long NV_GET_USER_PAGES_REMOTE(struct task_struct *tsk, -- struct mm_struct *mm, -- unsigned long start, -- unsigned long nr_pages, -- int write, -- int force, -- struct page **pages, -- struct vm_area_struct **vmas) -- { -- unsigned int flags = 0; -- -- if (write) -- flags |= FOLL_WRITE; -- if (force) -- flags |= FOLL_FORCE; -- -- return get_user_pages(tsk, mm, start, nr_pages, flags, pages, vmas); -- } -- #endif --#endif -- - #endif /* _NV_LINUX_H_ */ -diff -Naur a/kernel/nv-procfs.c b/kernel/nv-procfs.c ---- a/kernel/nv-procfs.c 2022-10-16 09:28:09.694227668 +0200 -+++ b/kernel/nv-procfs.c 2022-08-28 09:42:35.546184171 +0200 -@@ -409,6 +409,15 @@ - return ((status < 0) ? status : (int)count); - } - -+#if defined(NV_PROC_OPS_PRESENT) -+static struct proc_ops nv_procfs_registry_fops = { -+ .proc_open = nv_procfs_open_registry, -+ .proc_read = seq_read, -+ .proc_write = nv_procfs_write_file, -+ .proc_lseek = seq_lseek, -+ .proc_release = nv_procfs_close_registry, -+}; -+#else - static struct file_operations nv_procfs_registry_fops = { - .owner = THIS_MODULE, - .open = nv_procfs_open_registry, -@@ -417,6 +426,7 @@ - .llseek = seq_lseek, - .release = nv_procfs_close_registry, - }; -+#endif - - static int - nv_procfs_read_unbind_lock( -@@ -538,6 +548,15 @@ - return rc; - } - -+#if defined(NV_PROC_OPS_PRESENT) -+static struct proc_ops nv_procfs_unbind_lock_fops = { -+ .proc_open = nv_procfs_open_unbind_lock, -+ .proc_read = seq_read, -+ .proc_write = nv_procfs_write_file, -+ .proc_lseek = seq_lseek, -+ .proc_release = nv_procfs_close_unbind_lock, -+}; -+#else - static struct file_operations nv_procfs_unbind_lock_fops = { - .owner = THIS_MODULE, - .open = nv_procfs_open_unbind_lock, -@@ -546,6 +565,7 @@ - .llseek = seq_lseek, - .release = nv_procfs_close_unbind_lock, - }; -+#endif - - static int - nv_procfs_read_text_file( -diff -Naur a/kernel/nv-vm.c b/kernel/nv-vm.c ---- a/kernel/nv-vm.c 2022-10-16 09:28:09.694227668 +0200 -+++ b/kernel/nv-vm.c 2022-08-28 09:42:35.546184171 +0200 -@@ -12,6 +12,9 @@ - #include "os-interface.h" - #include "nv.h" - #include "nv-linux.h" -+#if defined(NV_ASM_SET_MEMORY_H_PRESENT) -+#include <asm/set_memory.h> -+#endif - - static inline void nv_set_contig_memory_uc(nv_pte_t *page_ptr, NvU32 num_pages) - { -@@ -169,12 +172,20 @@ - - static inline int nv_map_sg(struct pci_dev *dev, struct scatterlist *sg) - { -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) -+ return dma_map_sg(&dev->dev, sg, 1, DMA_BIDIRECTIONAL); -+#else - return pci_map_sg(dev, sg, 1, PCI_DMA_BIDIRECTIONAL); -+#endif - } - - static inline void nv_unmap_sg(struct pci_dev *dev, struct scatterlist *sg) - { -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) -+ dma_unmap_sg(&dev->dev, sg, 1, DMA_BIDIRECTIONAL); -+#else - pci_unmap_sg(dev, sg, 1, PCI_DMA_BIDIRECTIONAL); -+#endif - } - - #define NV_MAP_SG_MAX_RETRIES 16 -diff -Naur a/kernel/os-interface.c b/kernel/os-interface.c ---- a/kernel/os-interface.c 2022-10-16 09:28:09.741226595 +0200 -+++ b/kernel/os-interface.c 2022-08-28 09:42:35.550184084 +0200 -@@ -439,7 +439,7 @@ - NvU32 *useconds + * This function executes a _DDC ACPI method. + */ +@@ -1206,15 +1289,18 @@ ) { -- struct timeval tm; -+ nv_timeval tm; - - nv_gettimeofday(&tm); - -@@ -474,7 +474,7 @@ - unsigned long usec; - - #ifdef NV_CHECK_DELAY_ACCURACY -- struct timeval tm1, tm2; -+ nv_timeval tm1, tm2; - - nv_gettimeofday(&tm1); - #endif -@@ -514,9 +514,9 @@ - unsigned long MicroSeconds; - unsigned long jiffies; - unsigned long mdelay_safe_msec; -- struct timeval tm_end, tm_aux; -+ nv_timeval tm_end, tm_aux; - #ifdef NV_CHECK_DELAY_ACCURACY -- struct timeval tm_start; -+ nv_timeval tm_start; - #endif - - nv_gettimeofday(&tm_aux); -@@ -549,7 +549,7 @@ - // the requested timeout has expired, loop until less - // than a jiffie of the desired delay remains. - // -- current->state = TASK_INTERRUPTIBLE; -+ set_current_state(TASK_INTERRUPTIBLE); - do - { - schedule_timeout(jiffies); -diff -Naur a/kernel/os-interface.h b/kernel/os-interface.h ---- a/kernel/os-interface.h 2022-10-16 09:28:09.741226595 +0200 -+++ b/kernel/os-interface.h 2022-08-28 09:42:35.551184063 +0200 -@@ -24,7 +24,7 @@ - * * - \***************************************************************************/ - --#include <stdarg.h> -+#include "nv_stdarg.h" - - /* - * Define away Microsoft compiler extensions when possible -diff -Naur a/kernel/os-mlock.c b/kernel/os-mlock.c ---- a/kernel/os-mlock.c 2022-10-16 09:28:09.742226573 +0200 -+++ b/kernel/os-mlock.c 2022-08-28 09:42:35.551184063 +0200 -@@ -14,6 +14,8 @@ - #include "os-interface.h" - #include "nv-linux.h" - -+#include "nv-mm.h" -+ - RM_STATUS NV_API_CALL os_lock_user_pages( - void *address, - NvU64 page_count, -@@ -44,10 +46,10 @@ - return rmStatus; - } - -- down_read(&mm->mmap_sem); -+ nv_mmap_read_lock(mm); - ret = NV_GET_USER_PAGES((unsigned long)address, - page_count, write, force, user_pages, NULL); -- up_read(&mm->mmap_sem); -+ nv_mmap_read_unlock(mm); - pinned = ret; - - if (ret < 0) -diff -Naur a/kernel/uvm/conftest.sh b/kernel/uvm/conftest.sh ---- a/kernel/uvm/conftest.sh 2022-10-16 09:28:09.743226550 +0200 -+++ b/kernel/uvm/conftest.sh 2022-08-28 09:42:35.552184041 +0200 -@@ -176,6 +176,7 @@ - FILES="$FILES linux/ktime.h" - FILES="$FILES linux/file.h" - -+ FILES_ARCH="$FILES_ARCH asm/pgtable.h" - FILES_ARCH="$FILES_ARCH asm/set_memory.h" - - translate_and_find_header_files $HEADERS $FILES -@@ -440,6 +441,9 @@ - # Determine if the set_memory_array_uc() function is present. - # - CODE=" -+ #if defined(NV_ASM_PGTABLE_H_PRESENT) -+ #include <asm/pgtable.h> -+ #endif - #if defined(NV_ASM_SET_MEMORY_H_PRESENT) - #include <asm/set_memory.h> - #else -diff -Naur a/kernel/uvm/Makefile b/kernel/uvm/Makefile ---- a/kernel/uvm/Makefile 2022-10-16 09:28:09.742226573 +0200 -+++ b/kernel/uvm/Makefile 2022-08-28 09:42:35.551184063 +0200 -@@ -207,6 +207,7 @@ - - RM_MODULE_SYMVERS:= $(RM_OUT_DIR)/Module.symvers - UVM_MODULE_SYMVERS:= $(obj)/Module.symvers -+KBUILD_EXTRA_SYMBOLS:= $(UVM_MODULE_SYMVERS) - - module $(MODULE_NAME).ko: $(UVM_MODULE_SYMVERS) debug_diagnostics_printing - -diff -Naur a/kernel/uvm/nvidia_uvm_linux.h b/kernel/uvm/nvidia_uvm_linux.h ---- a/kernel/uvm/nvidia_uvm_linux.h 2022-10-16 09:28:09.744226527 +0200 -+++ b/kernel/uvm/nvidia_uvm_linux.h 2022-08-28 09:42:35.553184019 +0200 -@@ -141,7 +141,9 @@ - #if !defined(NV_VMWARE) - #include <asm/tlbflush.h> /* flush_tlb(), flush_tlb_all() */ - #endif --#include <asm/kmap_types.h> /* page table entry lookup */ -+#if defined(NV_ASM_KMAP_TYPES_H_PRESENT) -+ #include <asm/kmap_types.h> /* page table entry lookup */ + acpi_status status; ++ struct acpi_device *device = NULL; + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; + union acpi_object *ddc; + union acpi_object ddc_arg0 = { ACPI_TYPE_INTEGER }; + struct acpi_object_list input = { 1, &ddc_arg0 }; ++#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 0, 0) ++ struct list_head *node, *next; + nv_acpi_integer_t device_id = 0; +#endif + NvU32 i; + acpi_handle dev_handle = NULL; + acpi_handle lcd_dev_handle = NULL; +- acpi_handle handle = NULL; - #include <linux/interrupt.h> /* tasklets, interrupt helpers */ - #include <linux/timer.h> -@@ -156,7 +158,7 @@ - #include <asm/page.h> /* PAGE_OFFSET */ - #include <asm/pgtable.h> /* pte bit definitions */ - --#if defined(NVCPU_X86_64) && !defined(HAVE_COMPAT_IOCTL) -+#if defined(NVCPU_X86_64) && !defined(NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL) - #include <linux/syscalls.h> /* sys_ioctl() */ - #include <linux/ioctl32.h> /* register_ioctl32_conversion() */ - #endif -diff -Naur a/kernel/uvm/nvidia_uvm_lite_api.c b/kernel/uvm/nvidia_uvm_lite_api.c ---- a/kernel/uvm/nvidia_uvm_lite_api.c 2022-10-16 09:28:09.745226504 +0200 -+++ b/kernel/uvm/nvidia_uvm_lite_api.c 2022-08-28 09:42:35.554183997 +0200 -@@ -30,6 +30,12 @@ - #include "uvm_gpu_ops_tests.h" - #endif + if (!nv_acpi_get_device_handle(nv, &dev_handle)) + return RM_ERR_NOT_SUPPORTED; +@@ -1222,6 +1308,15 @@ + if (!dev_handle) + return RM_ERR_INVALID_ARGUMENT; -+#if defined (NV_MM_HAS_MMAP_LOCK) -+#define mmap_sem mmap_lock ++#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) ++ status = acpi_bus_get_device(dev_handle, &device); ++#else ++ return RM_ERR_NOT_SUPPORTED; +#endif + -+#include "nv-mm.h" ++ if (ACPI_FAILURE(status) || !device) ++ return RM_ERR_INVALID_ARGUMENT; + - // - // nvidia_uvm_lite_api.c - // -@@ -161,13 +167,13 @@ - return RM_ERR_NOT_SUPPORTED; - } - -- down_write(&current->mm->mmap_sem); -+ nv_mmap_write_lock(current->mm); - - vma = find_uvmlite_vma(pParams->requestedBase, pParams->length, filp); - - if (!vma) + if (!NV_MAY_SLEEP()) { -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - UVM_ERR_PRINT("Failed to find the vma (base: 0x%llx, length: %llu\n", - pParams->requestedBase, pParams->length); - return RM_ERR_UVM_ADDRESS_IN_USE; -@@ -178,7 +184,7 @@ - - if (!pRecord) - { -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - UVM_ERR_PRINT("attempted to commit region without a preceding mmap() " - "call\n"); - return RM_ERR_OBJECT_NOT_FOUND; -@@ -187,7 +193,7 @@ - if ((pRecord->baseAddress != pParams->requestedBase) || - (PAGE_ALIGN(pRecord->length) != PAGE_ALIGN(pParams->length))) - { -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - UVM_ERR_PRINT("attempted to commit region with different VA or length" - " than used by preceding mmap\n"); - return RM_ERR_UVM_ADDRESS_IN_USE; -@@ -206,7 +212,7 @@ - } - - up_write(&pPriv->uvmPrivLock); -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - - return rmStatus; - } -@@ -235,12 +241,12 @@ - pParams->requestedBase, pParams->length, - pParams->newStreamId); - -- down_write(&current->mm->mmap_sem); -+ nv_mmap_write_lock(current->mm); - - vma = find_uvmlite_vma(pParams->requestedBase, pParams->length, filp); - if (vma == NULL) - { -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - return RM_ERR_UVM_ADDRESS_IN_USE; - } - -@@ -250,7 +256,7 @@ - rmStatus = uvmlite_region_set_stream(pRecord, pParams->newStreamId); - - up_write(&pPriv->uvmPrivLock); -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - - return rmStatus; - } -@@ -264,11 +270,11 @@ - - UVM_DBG_PRINT_RL("streamID: 0x%llx\n", pParams->streamId); - -- down_write(&current->mm->mmap_sem); -+ nv_mmap_write_lock(current->mm); - down_write(&pPriv->uvmPrivLock); - rmStatus = uvmlite_set_stream_running(pPriv, pParams->streamId); - up_write(&pPriv->uvmPrivLock); -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - - return rmStatus; - } -@@ -290,12 +296,12 @@ - pParams->streamIdArray[pParams->nStreams - 1]); + #if defined(DEBUG) +@@ -1232,15 +1327,16 @@ + return RM_ERR_NOT_SUPPORTED; } -- down_write(&current->mm->mmap_sem); -+ nv_mmap_write_lock(current->mm); - down_write(&pPriv->uvmPrivLock); - rmStatus = uvmlite_set_streams_stopped(pPriv, pParams->streamIdArray, - pParams->nStreams); - up_write(&pPriv->uvmPrivLock); -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - return rmStatus; - } - -@@ -311,12 +317,12 @@ - "flags: 0x%x\n", - pParams->requestedBase, pParams->length, pParams->flags); - -- down_write(&current->mm->mmap_sem); -+ nv_mmap_write_lock(current->mm); - - vma = find_uvmlite_vma(pParams->requestedBase, pParams->length, filp); - if (vma == NULL) +- while (lcd_dev_handle == NULL) ++#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 0, 0) ++ list_for_each_safe(node, next, &device->children) { -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - return RM_ERR_UVM_ADDRESS_IN_USE; - } - -@@ -329,7 +335,7 @@ - vma, - pRecord); - up_write(&pPriv->uvmPrivLock); -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - - return rmStatus; - } -@@ -385,7 +391,7 @@ - return rmStatus; - } - -- down_write(&current->mm->mmap_sem); -+ nv_mmap_write_lock(current->mm); - rmStatus = RM_ERR_INVALID_ARGUMENT; - vma = find_counters_vma((unsigned long long) countersBaseAddress, - UVM_MAX_GPUS * UVM_PER_RESOURCE_COUNTERS_SIZE + -@@ -416,7 +422,7 @@ +- status = acpi_get_next_object(ACPI_TYPE_DEVICE, dev_handle, +- handle, &handle); +- if (ACPI_FAILURE(status) || (handle == NULL)) +- break; ++ struct acpi_device *dev = ++ list_entry(node, struct acpi_device, node); + +- status = acpi_evaluate_integer(handle, "_ADR", NULL, &device_id); ++ if (!dev) ++ continue; + ++ status = acpi_evaluate_integer(dev->handle, "_ADR", NULL, &device_id); + if (ACPI_FAILURE(status)) + /* Couldnt query device_id for this device */ + continue; +@@ -1249,12 +1345,15 @@ + + if ((device_id == 0x0110) || (device_id == 0x0118) || (device_id == 0x0400)) /* Only for an LCD*/ + { +- lcd_dev_handle = handle; ++ lcd_dev_handle = dev->handle; + nv_printf(NV_DBG_INFO, "NVRM: %s Found LCD: %x\n", __FUNCTION__, device_id); + break; } - } -- up_write(&current->mm->mmap_sem); -+ nv_mmap_write_unlock(current->mm); - - // - // We can not reverse uvm_map_page, so inserted pages will stay -diff -Naur a/kernel/uvm/nvidia_uvm_lite.c b/kernel/uvm/nvidia_uvm_lite.c ---- a/kernel/uvm/nvidia_uvm_lite.c 2022-10-16 09:28:09.745226504 +0200 -+++ b/kernel/uvm/nvidia_uvm_lite.c 2022-08-28 09:42:35.554183997 +0200 -@@ -131,8 +131,8 @@ - RM_STATUS _preexisting_error_on_channel(UvmGpuMigrationTracking *pMigTracker, - UvmCommitRecord *pRecord); - --static void _set_timeout_in_usec(struct timeval *src, -- struct timeval *result, -+static void _set_timeout_in_usec(nv_timeval *src, -+ nv_timeval *result, - unsigned long timeoutInUsec) - { - if (!src || !result) -@@ -820,7 +820,13 @@ - } - - #if defined(NV_VM_OPERATIONS_STRUCT_HAS_FAULT) -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0) -+vm_fault_t _fault(struct vm_fault *vmf) -+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) -+int _fault(struct vm_fault *vmf) -+#else - int _fault(struct vm_area_struct *vma, struct vm_fault *vmf) -+#endif - { - #if defined(NV_VM_FAULT_HAS_ADDRESS) - unsigned long vaddr = vmf->address; -@@ -828,8 +834,15 @@ - unsigned long vaddr = (unsigned long)vmf->virtual_address; - #endif - struct page *page = NULL; -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0) -+ vm_fault_t retval; + } +#else - int retval; - ++ acpi_dev_for_each_child(device, nv_acpi_ddc_method_enumerated, &lcd_dev_handle); +#endif -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) -+ struct vm_area_struct *vma = vmf->vma; -+#endif - retval = _fault_common(vma, vaddr, &page, vmf->flags); - vmf->page = page; -@@ -868,7 +881,13 @@ - // it's dealing with anonymous mapping (see handle_pte_fault). - // - #if defined(NV_VM_OPERATIONS_STRUCT_HAS_FAULT) -+#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0) -+vm_fault_t _sigbus_fault(struct vm_fault *vmf) -+#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) -+int _sigbus_fault(struct vm_fault *vmf) -+#else - int _sigbus_fault(struct vm_area_struct *vma, struct vm_fault *vmf) -+#endif - { - vmf->page = NULL; - return VM_FAULT_SIGBUS; -@@ -1992,9 +2011,9 @@ - static RM_STATUS _check_ecc_errors(UvmGpuMigrationTracking *pMigTracker, - NvBool *pIsEccErrorSet) - { -- struct timeval eccErrorStartTime = {0}; -- struct timeval eccErrorCurrentTime = {0}; -- struct timeval eccTimeout = {0}; -+ nv_timeval eccErrorStartTime = {0}; -+ nv_timeval eccErrorCurrentTime = {0}; -+ nv_timeval eccTimeout = {0}; - NvBool bEccErrorTimeout = NV_FALSE; - NvBool bEccIncomingError = NV_FALSE; - unsigned rmInterruptSet = 0; + if (lcd_dev_handle == NULL) + { diff --git a/import-files-from-390.151.patch b/import-files-from-390.157.patch similarity index 75% rename from import-files-from-390.151.patch rename to import-files-from-390.157.patch index 305ac9c..e974aef 100644 --- a/import-files-from-390.151.patch +++ b/import-files-from-390.157.patch @@ -1,6 +1,6 @@ diff -Naur a/kernel/conftest.h b/kernel/conftest.h --- a/kernel/conftest.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/conftest.h 2022-06-05 13:18:33.945571964 +0200 ++++ b/kernel/conftest.h 2023-03-04 13:26:25.825020285 +0100 @@ -0,0 +1,11 @@ +#ifndef _CONFTEST_H +#define _CONFTEST_H @@ -13,9 +13,254 @@ diff -Naur a/kernel/conftest.h b/kernel/conftest.h +#include "conftest/types.h" + +#endif +diff -Naur a/kernel/conftest.Kbuild b/kernel/conftest.Kbuild +--- a/kernel/conftest.Kbuild 1970-01-01 01:00:00.000000000 +0100 ++++ b/kernel/conftest.Kbuild 2023-03-04 13:26:40.788675312 +0100 +@@ -0,0 +1,241 @@ ++NV_CONFTEST_GENERIC_COMPILE_TESTS += drm_available ++NV_CONFTEST_GENERIC_COMPILE_TESTS += drm_atomic_available ++NV_CONFTEST_GENERIC_COMPILE_TESTS += dom0_kernel_present ++NV_CONFTEST_GENERIC_COMPILE_TESTS += nvmap_support ++ ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += remap_pfn_range ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += vmap ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += set_pages_uc ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += set_memory_uc ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += set_memory_array_uc ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += change_page_attr ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_get_class ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_choose_state ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += vm_insert_page ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += acquire_console_sem ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += console_lock ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += kmem_cache_create ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += kmem_cache_create_usercopy ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += on_each_cpu ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += smp_call_function ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_evaluate_integer ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_cache ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_nocache ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += ioremap_wc ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_walk_namespace ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_domain_nr ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += dma_mapping_error ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += file_operations ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_ops ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += sg_alloc_table ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += sg_init_table ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_get_domain_bus_and_slot ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_num_physpages ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_create_data ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pde_data ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += PDE_DATA ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += proc_remove ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pm_vt_switch_required ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += pci_save_state ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_pci_set_busid ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += write_cr4 ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += for_each_online_node ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += node_end_pfn ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_user_pages ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += get_user_pages_remote ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += register_cpu_notifier ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += cpuhp_setup_state ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_get_pci_dev ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_pci_init ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_legacy_pci_init ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += timer_setup ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += do_gettimeofday ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_gem_object_put_unlocked ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += efi_enabled ++ ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_gem_object_get ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_atomic_state_ref_counting ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_gem_object_lookup ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_dev_put ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_framebuffer_get ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += drm_connector_for_each_possible_encoder ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += vga_tryget ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += acpi_bus_get_device ++ ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += remap_page_range ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += address_space_init_once ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += kbasename ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += fatal_signal_pending ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += list_cut_position ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += vzalloc ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += wait_on_bit_lock_argument_count ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += bitmap_clear ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += usleep_range ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += radix_tree_empty ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += radix_tree_replace_slot ++NV_CONFTEST_FUNCTION_COMPILE_TESTS += ktime_get_raw_ts64 ++ ++NV_CONFTEST_SYMBOL_COMPILE_TESTS += efi_enabled ++NV_CONFTEST_SYMBOL_COMPILE_TESTS += export_symbol_gpl_conftest ++ ++NV_CONFTEST_TYPE_COMPILE_TESTS += i2c_adapter ++NV_CONFTEST_TYPE_COMPILE_TESTS += pm_message_t ++NV_CONFTEST_TYPE_COMPILE_TESTS += irq_handler_t ++NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_device_ops ++NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_op_remove ++NV_CONFTEST_TYPE_COMPILE_TESTS += acpi_device_id ++NV_CONFTEST_TYPE_COMPILE_TESTS += outer_flush_all ++NV_CONFTEST_TYPE_COMPILE_TESTS += proc_dir_entry ++NV_CONFTEST_TYPE_COMPILE_TESTS += scatterlist ++NV_CONFTEST_TYPE_COMPILE_TESTS += sg_table ++NV_CONFTEST_TYPE_COMPILE_TESTS += file_inode ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_present ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_has_bus_type ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_has_get_irq ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_bus_has_get_name ++NV_CONFTEST_TYPE_COMPILE_TESTS += vm_fault_t ++NV_CONFTEST_TYPE_COMPILE_TESTS += vm_fault_present ++NV_CONFTEST_TYPE_COMPILE_TESTS += vm_fault_has_address ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_unload_has_int_return_type ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_legacy_feature_bit_present ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_prime_flag_present ++ ++NV_CONFTEST_TYPE_COMPILE_TESTS += timeval ++NV_CONFTEST_TYPE_COMPILE_TESTS += mm_has_mmap_lock ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_gem_object_vmap_has_map_arg ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_device_has_pdev ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_mode_object_find_has_file_priv_arg ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_prime_pages_to_sg_has_drm_device_arg ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_gem_object_has_resv ++ ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_gem_prime_export_has_dev_arg ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_has_gem_prime_callbacks ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_has_gem_free_object ++NV_CONFTEST_TYPE_COMPILE_TESTS += drm_driver_has_gem_prime_res_obj ++NV_CONFTEST_TYPE_COMPILE_TESTS += vmalloc_has_pgprot_t_arg ++ ++NV_CONFTEST_TYPE_COMPILE_TESTS += vm_operations_struct ++NV_CONFTEST_TYPE_COMPILE_TESTS += task_struct ++NV_CONFTEST_TYPE_COMPILE_TESTS += kuid_t ++NV_CONFTEST_TYPE_COMPILE_TESTS += fault_flags ++NV_CONFTEST_TYPE_COMPILE_TESTS += atomic64_type ++NV_CONFTEST_TYPE_COMPILE_TESTS += address_space ++NV_CONFTEST_TYPE_COMPILE_TESTS += backing_dev_info ++NV_CONFTEST_TYPE_COMPILE_TESTS += mm_context_t ++NV_CONFTEST_TYPE_COMPILE_TESTS += vm_ops_fault_removed_vma_arg ++NV_CONFTEST_TYPE_COMPILE_TESTS += proc_ops ++NV_CONFTEST_TYPE_COMPILE_TESTS += pnv_npu2_init_context ++NV_CONFTEST_TYPE_COMPILE_TESTS += kmem_cache_has_kobj_remove_work ++NV_CONFTEST_TYPE_COMPILE_TESTS += sysfs_slab_unlink ++ ++NV_CONFTEST_MACRO_COMPILE_TESTS += INIT_WORK ++ ++# The conftest.sh script tests various aspects of the target kernel. ++# The per-module Kbuild files included above should: ++# ++# - Append to the NV_CONFTEST_*_COMPILE_TESTS variables to indicate ++# which conftests they require. ++# - Append to the NV_OBJECTS_DEPEND_ON_CONFTEST variable any object files ++# that depend on conftest. ++# ++# The conftest machinery below will run the requested tests and ++# generate the appropriate header files. ++# ++ ++CC ?= cc ++HOST_CC ?= $(CC) ++LD ?= ld ++ ++NV_CONFTEST_SCRIPT := $(src)/conftest.sh ++NV_CONFTEST_HEADER := $(obj)/conftest/headers.h ++ ++NV_CONFTEST_CMD := /bin/sh $(NV_CONFTEST_SCRIPT) \ ++ "$(CC)" "$(HOST_CC)" $(ARCH) $(KERNEL_SOURCES) $(KERNEL_OUTPUT) ++ ++NV_CONFTEST_CFLAGS := $(shell $(NV_CONFTEST_CMD) build_cflags) ++ ++NV_CONFTEST_COMPILE_TEST_HEADERS := $(obj)/conftest/macros.h ++NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/functions.h ++NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/symbols.h ++NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/types.h ++NV_CONFTEST_COMPILE_TEST_HEADERS += $(obj)/conftest/generic.h ++ ++NV_CONFTEST_HEADERS := $(obj)/conftest/patches.h ++NV_CONFTEST_HEADERS += $(obj)/conftest/headers.h ++NV_CONFTEST_HEADERS += $(NV_CONFTEST_COMPILE_TEST_HEADERS) ++ ++ ++# ++# Generate a header file for a single conftest compile test. Each compile test ++# header depends on conftest.sh, as well as the generated conftest/headers.h ++# file, which is included in the compile test preamble. ++# ++ ++$(obj)/conftest/compile-tests/%.h: $(NV_CONFTEST_SCRIPT) $(NV_CONFTEST_HEADER) ++ @mkdir -p $(obj)/conftest/compile-tests ++ @echo " CONFTEST: $(notdir $*)" ++ @$(NV_CONFTEST_CMD) compile_tests '$(NV_CONFTEST_CFLAGS)' \ ++ $(notdir $*) > $@ ++ ++# ++# Concatenate a conftest/*.h header from its constituent compile test headers ++# ++# $(1): The name of the concatenated header ++# $(2): The list of compile tests that make up the header ++# ++ ++define NV_GENERATE_COMPILE_TEST_HEADER ++ $(obj)/conftest/$(1).h: $(addprefix $(obj)/conftest/compile-tests/,$(addsuffix .h,$(2))) ++ @mkdir -p $(obj)/conftest ++ @# concatenate /dev/null to prevent cat from hanging when $$^ is empty ++ @cat $$^ /dev/null > $$@ ++endef ++ ++# ++# Generate the conftest compile test headers from the lists of compile tests ++# provided by the module-specific Kbuild files. ++# ++NV_CONFTEST_FUNCTION_COMPILE_TESTS ?= ++NV_CONFTEST_GENERIC_COMPILE_TESTS ?= ++NV_CONFTEST_MACRO_COMPILE_TESTS ?= ++NV_CONFTEST_SYMBOL_COMPILE_TESTS ?= ++NV_CONFTEST_TYPE_COMPILE_TESTS ?= ++ ++$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,functions,$(NV_CONFTEST_FUNCTION_COMPILE_TESTS))) ++$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,generic,$(NV_CONFTEST_GENERIC_COMPILE_TESTS))) ++$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,macros,$(NV_CONFTEST_MACRO_COMPILE_TESTS))) ++$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,symbols,$(NV_CONFTEST_SYMBOL_COMPILE_TESTS))) ++$(eval $(call NV_GENERATE_COMPILE_TEST_HEADER,types,$(NV_CONFTEST_TYPE_COMPILE_TESTS))) ++ ++$(obj)/conftest/patches.h: $(NV_CONFTEST_SCRIPT) ++ @mkdir -p $(obj)/conftest ++ @$(NV_CONFTEST_CMD) patch_check > $@ ++ ++$(obj)/conftest/headers.h: $(NV_CONFTEST_SCRIPT) ++ @mkdir -p $(obj)/conftest ++ @$(NV_CONFTEST_CMD) test_kernel_headers > $@ ++ ++clean-dirs := $(obj)/conftest ++ ++ ++# For any object files that depend on conftest, declare the dependency here. ++$(addprefix $(obj)/,$(NV_OBJECTS_DEPEND_ON_CONFTEST)): | $(NV_CONFTEST_HEADERS) ++ ++# Sanity checks of the build environment and target system/kernel ++ ++BUILD_SANITY_CHECKS = \ ++ cc_sanity_check \ ++ cc_version_check \ ++ dom0_sanity_check \ ++ xen_sanity_check \ ++ preempt_rt_sanity_check \ ++ vgpu_kvm_sanity_check ++ ++.PHONY: $(BUILD_SANITY_CHECKS) ++ ++$(BUILD_SANITY_CHECKS): ++ @$(NV_CONFTEST_CMD) $@ full_output ++ ++# Perform all sanity checks before generating the conftest headers ++ ++$(NV_CONFTEST_HEADERS): | $(BUILD_SANITY_CHECKS) diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh --- a/kernel/conftest.sh 2019-12-11 23:04:24.000000000 +0100 -+++ b/kernel/conftest.sh 2022-06-05 13:18:33.949571878 +0200 ++++ b/kernel/conftest.sh 2023-03-04 13:26:40.793675197 +0100 @@ -24,7 +24,6 @@ OUTPUT=$5 XEN_PRESENT=1 @@ -52,7 +297,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh done } -@@ -81,67 +83,13 @@ +@@ -81,80 +83,39 @@ for file in $@; do local file_define=NV_`echo $file | tr '/.' '_' | tr '-' '_' | tr 'a-z' 'A-Z'`_PRESENT if [ -f $parent_dir/$file -o -f $OUTPUT/include/$file ]; then @@ -122,9 +367,11 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh test_headers() { # # Determine which header files (of a set that may or may not be -@@ -149,12 +97,23 @@ + # present) are provided by the target kernel. # - FILES="asm/system.h" +- FILES="asm/system.h" ++ FILES="acpi/video.h" ++ FILES="$FILES asm/system.h" FILES="$FILES drm/drmP.h" + FILES="$FILES drm/drm_auth.h" FILES="$FILES drm/drm_gem.h" @@ -142,20 +389,12 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + FILES="$FILES drm/drm_vblank.h" FILES="$FILES drm/drm_file.h" FILES="$FILES drm/drm_ioctl.h" -- FILES="$FILES drm/drm_pci.h" + FILES="$FILES drm/drm_pci.h" + FILES="$FILES drm/drm_device.h" FILES="$FILES generated/autoconf.h" FILES="$FILES generated/compile.h" FILES="$FILES generated/utsrelease.h" -@@ -162,7 +121,6 @@ - FILES="$FILES linux/kconfig.h" - FILES="$FILES linux/screen_info.h" - FILES="$FILES linux/semaphore.h" -- FILES="$FILES linux/nvmap.h" - FILES="$FILES linux/printk.h" - FILES="$FILES linux/ratelimit.h" - FILES="$FILES linux/prio_tree.h" -@@ -171,27 +129,24 @@ +@@ -171,27 +132,27 @@ FILES="$FILES linux/bug.h" FILES="$FILES linux/sched/signal.h" FILES="$FILES linux/sched/task.h" @@ -163,7 +402,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh FILES="$FILES xen/ioemu.h" FILES="$FILES linux/fence.h" FILES="$FILES linux/ktime.h" -- FILES="$FILES linux/file.h" + FILES="$FILES linux/file.h" + FILES="$FILES linux/dma-resv.h" + FILES="$FILES linux/dma-map-ops.h" + FILES="$FILES linux/stdarg.h" @@ -175,6 +414,8 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + FILES_ARCH="$FILES_ARCH asm/powernv.h" + FILES_ARCH="$FILES_ARCH asm/tlbflush.h" + FILES_ARCH="$FILES_ARCH asm/pgtable_types.h" ++ FILES_ARCH="$FILES_ARCH asm/kmap_types.h" ++ FILES_ARCH="$FILES_ARCH asm/pgtable.h" translate_and_find_header_files $HEADERS $FILES translate_and_find_header_files $HEADERS_ARCH $FILES_ARCH @@ -193,7 +434,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh } build_cflags() { -@@ -202,72 +157,61 @@ +@@ -202,72 +163,61 @@ if [ "$OUTPUT" != "$SOURCES" ]; then OUTPUT_CFLAGS="-I$OUTPUT/include2 -I$OUTPUT/include" if [ -f "$OUTPUT/include/generated/autoconf.h" ]; then @@ -307,7 +548,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh if [ -n "$BUILD_PARAMS" ]; then CFLAGS="$CFLAGS -D$BUILD_PARAMS" fi -@@ -288,9 +232,31 @@ +@@ -288,9 +238,31 @@ CFLAGS="$CFLAGS -DCC_HAVE_ASM_GOTO" fi fi @@ -340,7 +581,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh #if defined(NV_LINUX_KCONFIG_H_PRESENT) #include <linux/kconfig.h> #endif -@@ -356,6 +322,47 @@ +@@ -356,6 +328,47 @@ fi } @@ -388,7 +629,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh get_configuration_option() { # # Print the value of given configuration option, if defined -@@ -424,6 +431,9 @@ +@@ -424,6 +437,9 @@ # CODE=" #if defined(NV_ASM_SET_MEMORY_H_PRESENT) @@ -398,7 +639,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh #include <asm/set_memory.h> #else #include <asm/cacheflush.h> -@@ -441,6 +451,9 @@ +@@ -441,6 +457,9 @@ # CODE=" #if defined(NV_ASM_SET_MEMORY_H_PRESENT) @@ -408,7 +649,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh #include <asm/set_memory.h> #else #include <asm/cacheflush.h> -@@ -452,12 +465,50 @@ +@@ -452,12 +471,50 @@ compile_check_conftest "$CODE" "NV_SET_MEMORY_ARRAY_UC_PRESENT" "" "functions" ;; @@ -459,7 +700,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh #include <asm/set_memory.h> #else #include <asm/cacheflush.h> -@@ -491,9 +542,7 @@ +@@ -491,9 +548,7 @@ #include <linux/version.h> #include <linux/utsname.h> #include <linux/mm.h> @@ -470,7 +711,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh void conftest_change_page_attr(void) { change_page_attr(); }" -@@ -554,6 +603,20 @@ +@@ -554,6 +609,20 @@ fi ;; @@ -491,43 +732,17 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh remap_pfn_range) # # Determine if the remap_pfn_range() function is -@@ -568,61 +631,37 @@ +@@ -568,6 +637,39 @@ compile_check_conftest "$CODE" "NV_REMAP_PFN_RANGE_PRESENT" "" "functions" ;; -- vmap) + hash__remap_4k_pfn) - # -- # Determine if the vmap() function is present and how -- # many arguments it takes. ++ # + # Determine if the hash__remap_4k_pfn() function is + # present. + # hash__remap_4k_pfn was added by this commit: + # 2016-04-29 6cc1a0ee4ce29ad1cbdc622db6f9bc16d3056067 - # -- echo "$CONFTEST_PREAMBLE -- #include <linux/vmalloc.h> -- void conftest_vmap(void) { -- vmap(); -- }" > conftest$$.c -- -- $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 -- rm -f conftest$$.c -- -- if [ -f conftest$$.o ]; then -- echo "#undef NV_VMAP_PRESENT" | append_conftest "functions" -- rm -f conftest$$.o -- return -- fi -- -- echo "$CONFTEST_PREAMBLE -- #include <linux/vmalloc.h> -- void *conftest_vmap(struct page **pages, int count) { -- return vmap(pages, count); -- }" > conftest$$.c -- -- $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 -- rm -f conftest$$.c ++ # + CODE=" + #if defined(NV_ASM_BOOK3S_64_HASH_64K_H_PRESENT) + #include <linux/mm.h> @@ -536,49 +751,28 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + void conftest_hash__remap_4k_pfn(void) { + hash__remap_4k_pfn(); + }" - -- if [ -f conftest$$.o ]; then -- echo "#define NV_VMAP_PRESENT" | append_conftest "functions" -- echo "#define NV_VMAP_ARGUMENT_COUNT 2" | append_conftest "functions" -- rm -f conftest$$.o -- return -- fi ++ + compile_check_conftest "$CODE" "NV_HASH__REMAP_4K_PFN_PRESENT" "" "functions" + ;; - -- echo "$CONFTEST_PREAMBLE -- #include <linux/vmalloc.h> ++ + follow_pfn) + # + # Determine if the follow_pfn() function is + # present. + # + CODE=" - #include <linux/mm.h> -- void *conftest_vmap(struct page **pages, int count) { -- return vmap(pages, count, 0, PAGE_KERNEL); -- }" > conftest$$.c -- -- $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 -- rm -f conftest$$.c ++ #include <linux/mm.h> + void conftest_follow_pfn(void) { + follow_pfn(); + }" - -- if [ -f conftest$$.o ]; then -- echo "#define NV_VMAP_PRESENT" | append_conftest "functions" -- echo "#define NV_VMAP_ARGUMENT_COUNT 4" | append_conftest "functions" -- rm -f conftest$$.o -- return -- else -- echo "#error vmap() conftest failed!" | append_conftest "functions" -- return -- fi ++ + compile_check_conftest "$CODE" "NV_FOLLOW_PFN_PRESENT" "" "functions" - ;; - - i2c_adapter) -@@ -768,6 +807,20 @@ ++ ;; ++ + vmap) + # + # Determine if the vmap() function is present and how +@@ -768,6 +870,20 @@ fi ;; @@ -599,24 +793,28 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh acpi_device_ops) # # Determine if the 'acpi_device_ops' structure has -@@ -1059,16 +1112,6 @@ - compile_check_conftest "$CODE" "NV_CPUHP_SETUP_STATE_PRESENT" "" "functions" - ;; +@@ -790,12 +906,19 @@ -- nvmap_support) -- # check if nvmap is supported. -- if [ -f nv-android.h ]; then -- echo "#define HAVE_NV_ANDROID" | append_conftest "generic" -- return -- else -- echo "#undef HAVE_NV_ANDROID" | append_conftest "generic" -- fi -- ;; -- - acpi_evaluate_integer) - # - # Determine if the acpi_evaluate_integer() function is -@@ -1188,6 +1231,19 @@ + echo "$CONFTEST_PREAMBLE + #include <linux/acpi.h> ++ #include <linux/version.h> + + acpi_op_remove conftest_op_remove_routine; + ++ #if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 2, 0) ++ void conftest_acpi_device_ops_remove(struct acpi_device *device) { ++ return conftest_op_remove_routine(device); ++ } ++ #else + int conftest_acpi_device_ops_remove(struct acpi_device *device) { + return conftest_op_remove_routine(device); +- }" > conftest$$.c ++ } ++ #endif" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c +@@ -1188,6 +1311,19 @@ compile_check_conftest "$CODE" "NV_IOREMAP_CACHE_PRESENT" "" "functions" ;; @@ -636,55 +834,62 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh ioremap_wc) # # Determine if the ioremap_wc() function is present. -@@ -1371,47 +1427,6 @@ - compile_check_conftest "$CODE" "NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL" "" "types" +@@ -1271,43 +1407,41 @@ + fi ;; -- sg_init_table) -- # -- # Determine if the sg_init_table() function is present. -- # -- echo "$CONFTEST_PREAMBLE -- #include <linux/scatterlist.h> -- void conftest_sg_init_table(struct scatterlist *sgl, -- unsigned int nents) { -- }" > conftest$$.c -- -- $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 -- rm -f conftest$$.c -- -- if [ ! -f conftest$$.o ]; then -- echo "#undef NV_SG_INIT_TABLE_PRESENT" | append_conftest "functions" -- return -- -- fi -- rm -f conftest$$.o -- -- echo "$CONFTEST_PREAMBLE -- #include <linux/types.h> -- #include <linux/scatterlist.h> -- void conftest_sg_init_table(struct scatterlist *sgl, -- unsigned int nents) { -- sg_init_table(); -- }" > conftest$$.c -- -- $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 -- rm -f conftest$$.c -- -- if [ -f conftest$$.o ]; then -- echo "#undef NV_SG_INIT_TABLE_PRESENT" | append_conftest "functions" -- rm -f conftest$$.o -- return -- else -- echo "#define NV_SG_INIT_TABLE_PRESENT" | append_conftest "functions" -- return -- fi -- ;; -- - sg_table) +- pci_dma_mapping_error) ++ dma_mapping_error) # - # Determine if the struct sg_table type is present. -@@ -1431,7 +1446,7 @@ +- # Determine how many arguments pci_dma_mapping_error() ++ # Determine how many arguments dma_mapping_error() + # takes. + # + echo "$CONFTEST_PREAMBLE +- #include <linux/pci.h> +- int conftest_pci_dma_mapping_error(void) { +- return pci_dma_mapping_error(NULL, 0); ++ #include <linux/dma-mapping.h> ++ int conftest_dma_mapping_error(void) { ++ return dma_mapping_error(NULL, 0); + }" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ -f conftest$$.o ]; then +- echo "#define NV_PCI_DMA_MAPPING_ERROR_PRESENT" | append_conftest "functions" +- echo "#define NV_PCI_DMA_MAPPING_ERROR_ARGUMENT_COUNT 2" | append_conftest "functions" ++ echo "#define NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT 2" | append_conftest "functions" + rm -f conftest$$.o + return + fi + + echo "$CONFTEST_PREAMBLE +- #include <linux/pci.h> +- int conftest_pci_dma_mapping_error(void) { +- return pci_dma_mapping_error(0); ++ #include <linux/dma-mapping.h> ++ int conftest_dma_mapping_error(void) { ++ return dma_mapping_error(0); + }" > conftest$$.c + + $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 + rm -f conftest$$.c + + if [ -f conftest$$.o ]; then +- echo "#define NV_PCI_DMA_MAPPING_ERROR_PRESENT" | append_conftest "functions" +- echo "#define NV_PCI_DMA_MAPPING_ERROR_ARGUMENT_COUNT 1" | append_conftest "functions" ++ echo "#define NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT 1" | append_conftest "functions" + rm -f conftest$$.o + return + else +- echo "#error pci_dma_mapping_error() conftest failed!" | append_conftest "functions" ++ echo "#error dma_mapping_error() conftest failed!" | append_conftest "functions" + return + fi + ;; +@@ -1431,7 +1565,7 @@ # echo "$CONFTEST_PREAMBLE #include <linux/scatterlist.h> @@ -693,7 +898,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh }" > conftest$$.c $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 -@@ -1447,7 +1462,7 @@ +@@ -1447,7 +1581,7 @@ CODE=" #include <linux/scatterlist.h> @@ -702,7 +907,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh sg_alloc_table(); }" -@@ -1520,6 +1535,197 @@ +@@ -1520,6 +1654,197 @@ return ;; @@ -900,7 +1105,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh drm_available) # # Determine if the DRM subsystem is usable -@@ -1533,26 +1739,47 @@ +@@ -1533,26 +1858,47 @@ #include <drm/drm_drv.h> #endif @@ -958,7 +1163,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh proc_create_data) # # Determine if the proc_create_data() function is present. -@@ -1569,6 +1796,23 @@ +@@ -1569,15 +1915,35 @@ pde_data) # @@ -981,8 +1186,12 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + # # Determine if the PDE_DATA() function is present. # ++ # Added by commit d9dda78bad87 ++ # ("procfs: new helper - PDE_DATA(inode)") in v3.10 ++ # CODE=" -@@ -1577,7 +1821,7 @@ + #include <linux/proc_fs.h> + void conftest_PDE_DATA(void) { PDE_DATA(); }" @@ -991,7 +1200,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh ;; get_num_physpages) -@@ -1610,7 +1854,7 @@ +@@ -1610,7 +1976,7 @@ vm_operations_struct) # # Determine if the 'vm_operations_struct' structure has @@ -1000,7 +1209,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh # CODE=" #include <linux/mm.h> -@@ -1619,45 +1863,56 @@ +@@ -1619,45 +1985,56 @@ }" compile_check_conftest "$CODE" "NV_VM_OPERATIONS_STRUCT_HAS_FAULT" "" "types" @@ -1084,7 +1293,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh task_struct) # # Determine if the 'task_struct' structure has -@@ -1672,6 +1927,20 @@ +@@ -1672,6 +2049,20 @@ compile_check_conftest "$CODE" "NV_TASK_STRUCT_HAS_CRED" "" "types" ;; @@ -1105,7 +1314,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh address_space) # # Determine if the 'address_space' structure has -@@ -1755,6 +2024,19 @@ +@@ -1755,6 +2146,19 @@ compile_check_conftest "$CODE" "NV_PM_VT_SWITCH_REQUIRED_PRESENT" "" "functions" ;; @@ -1125,19 +1334,15 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh file_inode) # -@@ -1770,19 +2052,133 @@ - compile_check_conftest "$CODE" "NV_FILE_HAS_INODE" "" "types" +@@ -1785,6 +2189,135 @@ + compile_check_conftest "$CODE" "NV_DRM_PCI_SET_BUSID_PRESENT" "" "functions" ;; -- drm_pci_set_busid) + xen_ioemu_inject_msi) - # -- # Determine if the drm_pci_set_busid function is present. ++ # + # Determine if the xen_ioemu_inject_msi() function is present. - # - CODE=" -- #if defined(NV_DRM_DRMP_H_PRESENT) -- #include <drm/drmP.h> ++ # ++ CODE=" + #if defined(NV_XEN_IOEMU_H_PRESENT) + #include <linux/kernel.h> + #include <xen/interface/xen.h> @@ -1204,9 +1409,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + #include <linux/dma-map-ops.h> + #else + #include <linux/dma-mapping.h> - #endif -- void conftest_drm_pci_set_busid(void) { -- drm_pci_set_busid(); ++ #endif + void conftest_dma_map_ops(void) { + struct dma_map_ops ops; + }" @@ -1259,14 +1462,15 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + #include <linux/dma-mapping.h> + void conftest_dma_map_resource(void) { + dma_map_resource(); - }" - -- compile_check_conftest "$CODE" "NV_DRM_PCI_SET_BUSID_PRESENT" "" "functions" ++ }" ++ + compile_check_conftest "$CODE" "NV_DMA_MAP_RESOURCE_PRESENT" "" "functions" - ;; - ++ ;; ++ write_cr4) -@@ -1798,6 +2194,66 @@ + # + # Determine if the write_cr4() function is present. +@@ -1798,6 +2331,66 @@ compile_check_conftest "$CODE" "NV_WRITE_CR4_PRESENT" "" "functions" ;; @@ -1333,7 +1537,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh for_each_online_node) # # Determine if the for_each_online_node() function is present. -@@ -1824,6 +2280,705 @@ +@@ -1824,6 +2417,705 @@ compile_check_conftest "$CODE" "NV_NODE_END_PFN_PRESENT" "" "functions" ;; @@ -2039,7 +2243,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh get_user_pages) # # Conftest for get_user_pages() -@@ -1841,7 +2996,7 @@ +@@ -1841,7 +3133,7 @@ # 2016 Oct 12: 768ae309a96103ed02eb1e111e838c87854d8b51 # # linux-4.4.168 cherry-picked commit 768ae309a961 without @@ -2048,7 +2252,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh # # Conftest #1: Check if get_user_pages accepts 6 arguments. # Return if true. -@@ -1921,7 +3076,6 @@ +@@ -1921,7 +3213,6 @@ return fi @@ -2056,7 +2260,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh echo "#define NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" echo "#define NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" -@@ -1931,7 +3085,7 @@ +@@ -1931,7 +3222,7 @@ get_user_pages_remote) # # Determine if the function get_user_pages_remote() is @@ -2065,7 +2269,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh # # get_user_pages_remote() was added by: # 2016 Feb 12: 1e9877902dc7e11d2be038371c6fbf2dfcd469d7 -@@ -1944,13 +3098,17 @@ +@@ -1944,13 +3235,17 @@ # get_user_pages_remote() added 'locked' parameter # 2016 Dec 14:5b56d49fc31dbb0487e14ead790fc81ca9fb2c99 # @@ -2084,7 +2288,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh get_user_pages_remote(); }" > conftest$$.c -@@ -1959,6 +3117,7 @@ +@@ -1959,6 +3254,7 @@ if [ -f conftest$$.o ]; then echo "#undef NV_GET_USER_PAGES_REMOTE_PRESENT" | append_conftest "functions" @@ -2092,7 +2296,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" echo "#undef NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG" | append_conftest "functions" rm -f conftest$$.o -@@ -1986,14 +3145,20 @@ +@@ -1986,14 +3282,20 @@ rm -f conftest$$.c if [ -f conftest$$.o ]; then @@ -2114,7 +2318,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh echo "$CONFTEST_PREAMBLE #include <linux/mm.h> long get_user_pages_remote(struct task_struct *tsk, -@@ -2011,13 +3176,238 @@ +@@ -2011,13 +3313,238 @@ rm -f conftest$$.c if [ -f conftest$$.o ]; then @@ -2167,7 +2371,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + void conftest_usleep_range(void) { + usleep_range(); + }" - ++ + compile_check_conftest "$CODE" "NV_USLEEP_RANGE_PRESENT" "" "functions" + ;; + @@ -2273,7 +2477,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + int conftest_drm_mode_config_funcs_has_atomic_state_alloc(void) { + return offsetof(struct drm_mode_config_funcs, atomic_state_alloc); + }" -+ + + compile_check_conftest "$CODE" "NV_DRM_MODE_CONFIG_FUNCS_HAS_ATOMIC_STATE_ALLOC" "" "types" + ;; + @@ -2354,7 +2558,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh ;; drm_driver_unload_has_int_return_type) -@@ -2032,38 +3422,192 @@ +@@ -2032,18 +3559,49 @@ #include <drm/drmP.h> #endif @@ -2371,7 +2575,49 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh compile_check_conftest "$CODE" "NV_DRM_DRIVER_UNLOAD_HAS_INT_RETURN_TYPE" "" "types" ;; -- drm_legacy_pci_init) ++ drm_get_pci_dev) ++ # ++ # Determine if drm_get_pci_dev() is present. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_PCI_H_PRESENT) ++ #include <drm/drm_pci.h> ++ #endif ++ ++ void conftest_drm_legacy_pci_init(void) { ++ drm_get_pci_dev(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_GET_PCI_DEV_PRESENT" "" "functions" ++ ;; ++ ++ drm_pci_init) ++ # ++ # Determine if drm_pci_init() is present. ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ void conftest_drm_legacy_pci_init(void) { ++ drm_pci_init(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DRM_PCI_INIT_PRESENT" "" "functions" ++ ;; ++ + drm_legacy_pci_init) + # + # Determine if drm_legacy_pci_init() is present. drm_pci_init() was +@@ -2066,6 +3624,187 @@ + compile_check_conftest "$CODE" "NV_DRM_LEGACY_PCI_INIT_PRESENT" "" "functions" + ;; + + kref_has_refcount_of_type_refcount_t) + CODE=" + #include <linux/kref.h> @@ -2392,19 +2638,14 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + ;; + + drm_atomic_helper_disable_all) - # -- # Determine if drm_legacy_pci_init() is present. drm_pci_init() was -- # deprecated and renamed to drm_legacy_pci_init by: ++ # + # Determine if the function drm_atomic_helper_disable_all() is + # present. - # -- # 2017-05-24 10631d724deff712343d96dd3017cd323349f761 ++ # + # drm_atomic_helper_disable_all() has been added by: + # 2015-12-02 1494276000db789c6d2acd85747be4707051c801 - # - CODE=" -- #if defined(NV_DRM_DRMP_H_PRESENT) -- #include <drm/drmP.h> ++ # ++ CODE=" + #if defined(NV_DRM_DRM_ATOMIC_HELPER_H_PRESENT) + #include <drm/drm_atomic_helper.h> + #endif @@ -2489,16 +2730,14 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + CODE=" + #if defined(NV_DRM_DRM_ATOMIC_HELPER_H_PRESENT) + #include <drm/drm_atomic_helper.h> - #endif ++ #endif + void conftest_drm_atomic_helper_connector_dpms(void) { + drm_atomic_helper_connector_dpms(); + }" + + compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_CONNECTOR_DPMS_PRESENT" "" "functions" + ;; - -- #if defined(NV_DRM_DRM_PCI_H_PRESENT) -- #include <drm/drm_pci.h> ++ + backlight_device_register) + # + # Determine if the backlight_device_register() function is present @@ -2510,9 +2749,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + #include <linux/backlight.h> + #if !defined(CONFIG_BACKLIGHT_CLASS_DEVICE) + #error Backlight class device not enabled - #endif -- void conftest_drm_legacy_pci_init(void) { -- drm_legacy_pci_init(); ++ #endif + void conftest_backlight_device_register(void) { + backlight_device_register(NULL, NULL, NULL, NULL, NULL); + }" > conftest$$.c @@ -2540,9 +2777,8 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + void conftest_backlight_props_type(void) { + struct backlight_properties tmp; + tmp.type = BACKLIGHT_RAW; - }" - -- compile_check_conftest "$CODE" "NV_DRM_LEGACY_PCI_INIT_PRESENT" "" "functions" ++ }" ++ + compile_check_conftest "$CODE" "NV_BACKLIGHT_PROPERTIES_TYPE_PRESENT" "" "types" + ;; + @@ -2561,10 +2797,12 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + return register_acpi_notifier(); + }" + compile_check_conftest "$CODE" "NV_REGISTER_ACPI_NOTIFER_PRESENT" "" "functions" - ;; - ++ ;; ++ timer_setup) -@@ -2081,7 +3625,172 @@ + # + # Determine if the function timer_setup() is present. +@@ -2081,7 +3820,172 @@ compile_check_conftest "$CODE" "NV_TIMER_SETUP_PRESENT" "" "functions" ;; @@ -2738,7 +2976,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh # # Determine if the function do_gettimeofday() is # present. -@@ -2109,9 +3818,32 @@ +@@ -2109,9 +4013,32 @@ compile_check_conftest "$CODE" "NV_DO_GETTIMEOFDAY_PRESENT" "" "functions" ;; @@ -2773,7 +3011,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh # # Added by commit e6b62714e87c8811d5564b6a0738dcde63a51774 (drm: # Introduce drm_gem_object_{get,put}()) on 2017-02-28. -@@ -2124,20 +3856,19 @@ +@@ -2124,11 +4051,129 @@ #if defined(NV_DRM_DRM_GEM_H_PRESENT) #include <drm/drm_gem.h> #endif @@ -2785,26 +3023,23 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh - compile_check_conftest "$CODE" "NV_DRM_GEM_OBJECT_PUT_UNLOCKED_PRESENT" "" "functions" + compile_check_conftest "$CODE" "NV_DRM_GEM_OBJECT_GET_PRESENT" "" "functions" - ;; - -- drm_driver_legacy_feature_bit_present) ++ ;; ++ + drm_dev_put) - # -- # Determine if the DRIVER_LEGACY feature bit is present, either as a -- # preprocessor macro or in an enum. ++ # + # Determine if the function drm_dev_put() is present. - # -- # The DRIVER_* feature bits were changed from CPP macros to an enum -- # with commit 0e2a933b02c972919f7478364177eb76cd4ae00d (2019-01-29). ++ # + # Added by commit 9a96f55034e41b4e002b767e9218d55f03bdff7d (drm: + # introduce drm_dev_{get/put} functions) on 2017-09-26. - # - CODE=" - #if defined(NV_DRM_DRMP_H_PRESENT) -@@ -2147,14 +3878,108 @@ - #if defined(NV_DRM_DRM_DRV_H_PRESENT) - #include <drm/drm_drv.h> - #endif ++ # ++ CODE=" ++ #if defined(NV_DRM_DRMP_H_PRESENT) ++ #include <drm/drmP.h> ++ #endif ++ ++ #if defined(NV_DRM_DRM_DRV_H_PRESENT) ++ #include <drm/drm_drv.h> ++ #endif + void conftest_drm_dev_put(void) { + drm_dev_put(); + }" @@ -2844,9 +3079,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + + compile_check_conftest "$CODE" "NV_DRM_CONNECTOR_LIST_ITER_BEGIN_PRESENT" "" "functions" + ;; - -- void conftest_drm_driver_legacy_feature_bit_present(struct drm_driver *drv) { -- drv->driver_features = DRIVER_LEGACY; ++ + drm_atomic_helper_swap_state_has_stall_arg) + # + # Determine if drm_atomic_helper_swap_state() has 'stall' argument. @@ -2863,9 +3096,8 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + struct drm_atomic_state *state, + bool stall) { + (void)drm_atomic_helper_swap_state(state, stall); - }" - -- compile_check_conftest "$CODE" "NV_DRM_DRIVER_LEGACY_FEATURE_BIT_PRESENT" "" "types" ++ }" ++ + compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_SWAP_STATE_HAS_STALL_ARG" | append_conftest "types" + + # @@ -2886,8 +3118,8 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + }" + + compile_check_conftest "$CODE" "NV_DRM_ATOMIC_HELPER_SWAP_STATE_RETURN_INT" | append_conftest "types" - ;; - ++ ;; ++ + dma_direct_map_resource) + # + # Determine whether dma_is_direct() exists. @@ -2909,11 +3141,18 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + }" + + compile_check_conftest "$CODE" "NV_DMA_IS_DIRECT_PRESENT" "" "functions" -+ ;; + ;; + drm_driver_legacy_feature_bit_present) +@@ -2155,7 +4200,6 @@ + compile_check_conftest "$CODE" "NV_DRM_DRIVER_LEGACY_FEATURE_BIT_PRESENT" "" "types" + ;; + +- drm_driver_prime_flag_present) # -@@ -2181,6 +4006,7 @@ + # Determine whether driver feature flag DRIVER_PRIME is present. +@@ -2181,6 +4225,7 @@ #if defined(NV_DRM_DRM_DRV_H_PRESENT) #include <drm/drm_drv.h> #endif @@ -2921,7 +3160,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh unsigned int drm_driver_prime_flag_present_conftest(void) { return DRIVER_PRIME; }" -@@ -2188,12 +4014,546 @@ +@@ -2188,12 +4233,642 @@ compile_check_conftest "$CODE" "NV_DRM_DRIVER_PRIME_FLAG_PRESENT" "" "types" ;; @@ -3462,6 +3701,102 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + compile_check_conftest "$CODE" "NV_ACPI_BUS_GET_DEVICE_PRESENT" "" "functions" + ;; + ++ dma_resv_add_fence) ++ # ++ # Determine if the dma_resv_add_fence() function is present. ++ # ++ # dma_resv_add_excl_fence() and dma_resv_add_shared_fence() were ++ # removed and replaced with dma_resv_add_fence() by commit ++ # 73511edf8b19 ("dma-buf: specify usage while adding fences to ++ # dma_resv obj v7") in linux-next, expected in v5.19-rc1. ++ # ++ CODE=" ++ #if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ #include <linux/dma-resv.h> ++ #endif ++ void conftest_dma_resv_add_fence(void) { ++ dma_resv_add_fence(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DMA_RESV_ADD_FENCE_PRESENT" "" "functions" ++ ;; ++ ++ dma_resv_reserve_fences) ++ # ++ # Determine if the dma_resv_reserve_fences() function is present. ++ # ++ # dma_resv_reserve_shared() was removed and replaced with ++ # dma_resv_reserve_fences() by commit c8d4c18bfbc4 ++ # ("dma-buf/drivers: make reserving a shared slot mandatory v4") in ++ # linux-next, expected in v5.19-rc1. ++ # ++ CODE=" ++ #if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ #include <linux/dma-resv.h> ++ #endif ++ void conftest_dma_resv_reserve_fences(void) { ++ dma_resv_reserve_fences(); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_DMA_RESV_RESERVE_FENCES_PRESENT" "" "functions" ++ ;; ++ ++ reservation_object_reserve_shared_has_num_fences_arg) ++ # ++ # Determine if reservation_object_reserve_shared() has 'num_fences' ++ # argument. ++ # ++ # reservation_object_reserve_shared() function prototype was updated ++ # to take 'num_fences' argument by commit ca05359f1e64 ("dma-buf: ++ # allow reserving more than one shared fence slot") in v4.21-rc1 ++ # (2018-12-14). ++ # ++ CODE=" ++ #include <linux/reservation.h> ++ void conftest_reservation_object_reserve_shared_has_num_fences_arg( ++ struct reservation_object *obj, ++ unsigned int num_fences) { ++ (void) reservation_object_reserve_shared(obj, num_fences); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_RESERVATION_OBJECT_RESERVE_SHARED_HAS_NUM_FENCES_ARG" "" "types" ++ ;; ++ ++ acpi_video_backlight_use_native) ++ # ++ # Determine if acpi_video_backlight_use_native() function is present ++ # ++ # acpi_video_backlight_use_native was added by commit 2600bfa3df99 ++ # (ACPI: video: Add acpi_video_backlight_use_native() helper) for ++ # v6.0 (2022-08-17). Note: the include directive for <linux/types.h> ++ # in this conftest is necessary in order to support kernels between ++ # commit 0b9f7d93ca61 ("ACPI / i915: ignore firmware requests for ++ # backlight change") for v3.16 (2014-07-07) and commit 3bd6bce369f5 ++ # ("ACPI / video: Port to new backlight interface selection API") ++ # for v4.2 (2015-07-16). Kernels within this range use the 'bool' ++ # type and the related 'false' value in <acpi/video.h> without first ++ # including the definitions of that type and value. ++ # ++ # Building code that includes <acpi/video.h> was broken in a similar ++ # manner when building a kernel without ACPI support enabled, for a ++ # brief period between commit e92a71624025 on 2010-01-12 ("ACPI: ++ # Export EDID blocks to the kernel"), which added a stub function ++ # to <acpi/video.h> that returned -ENODEV without including any ++ # headers that defined ENODEV (or any headers at all), and commit ++ # b72512ed706e on 2010-09-05 ("ACPI: video: fix build for ++ # CONFIG_ACPI=n"), which added an <include/errno.h>. Linux 2.6.35 ++ # and 2.6.36 were released with <acpi/video.h> broken in this way. ++ # ++ CODE=" ++ #include <linux/types.h> ++ #include <linux/errno.h> ++ #include <acpi/video.h> ++ void conftest_acpi_video_backglight_use_native(void) { ++ acpi_video_backlight_use_native(0); ++ }" ++ ++ compile_check_conftest "$CODE" "NV_ACPI_VIDEO_BACKLIGHT_USE_NATIVE" "" "functions" ++ ;; esac } @@ -3471,7 +3806,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh case "$6" in cc_sanity_check) # -@@ -2239,137 +4599,85 @@ +@@ -2239,137 +4914,85 @@ cc_version_check) # @@ -3579,21 +3914,21 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh echo ""; - echo "gcc-version-check failed:"; + echo "Compiler version check failed:"; -+ echo ""; -+ echo "The major and minor number of the compiler used to"; -+ echo "compile the kernel:"; echo ""; - echo "$MSG" | fmt -w 52 -+ echo "${kernel_cc_string}"; ++ echo "The major and minor number of the compiler used to"; ++ echo "compile the kernel:"; echo ""; - echo "If you know what you are doing and want to override"; - echo "the gcc version check, you can do so by setting the"; - echo "IGNORE_CC_MISMATCH environment variable to \"1\"."; -+ echo "does not match the compiler used here:"; ++ echo "${kernel_cc_string}"; echo ""; - echo "In any other case, set the CC environment variable"; - echo "to the name of the compiler that was used to compile"; - echo "the kernel."; ++ echo "does not match the compiler used here:"; ++ echo ""; + $CC --version + echo ""; + echo "It is recommended to set the CC environment variable"; @@ -3671,7 +4006,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh fi ;; -@@ -2449,52 +4757,6 @@ +@@ -2449,52 +5072,6 @@ fi ;; @@ -3724,7 +4059,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh xen_sanity_check) # # Check if the target kernel is a Xen kernel. If so, exit, since -@@ -2506,6 +4768,8 @@ +@@ -2506,6 +5083,8 @@ exit 0 fi @@ -3733,7 +4068,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh if [ "$XEN_PRESENT" != "0" ]; then echo "The kernel you are installing for is a Xen kernel!"; echo ""; -@@ -2571,7 +4835,7 @@ +@@ -2571,7 +5150,7 @@ for PATCH in patch-*.h; do if [ -f $PATCH ]; then @@ -3742,7 +4077,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh PATCHES="$PATCHES "`echo $PATCH | sed -s 's/patch-\(.*\)\.h/\1/'` fi done -@@ -2579,14 +4843,11 @@ +@@ -2579,14 +5158,11 @@ echo "static struct { const char *short_description; const char *description; @@ -3760,7 +4095,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh exit 0 ;; -@@ -2596,20 +4857,13 @@ +@@ -2596,20 +5172,13 @@ # Run a series of compile tests to determine the set of interfaces # and features available in the target kernel. # @@ -3784,7 +4119,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh exit 0 ;; -@@ -2635,7 +4889,33 @@ +@@ -2635,7 +5204,33 @@ exit 1 fi ;; @@ -3819,7 +4154,7 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh test_configuration_option) # # Check to see if the given config option is set. -@@ -2679,4 +4959,25 @@ +@@ -2679,4 +5274,25 @@ exit 1 ;; @@ -3839,15 +4174,813 @@ diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh + # Generate CFLAGS for use in the compile tests + # + -+ build_cflags -+ echo $CFLAGS -+ exit 0 -+ ;; ++ build_cflags ++ echo $CFLAGS ++ exit 0 ++ ;; ++ + esac +diff -Naur a/kernel/dkms.conf b/kernel/dkms.conf +--- a/kernel/dkms.conf 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/dkms.conf 2023-03-04 13:26:40.793675197 +0100 +@@ -1,7 +1,13 @@ ++if [ -x /usr/bin/nproc ]; then ++ num_cpu_cores=$(nproc) ++else ++ num_cpu_cores=1 ++fi ++ + PACKAGE_NAME="nvidia" + PACKAGE_VERSION="340.108" + BUILT_MODULE_NAME[0]="$PACKAGE_NAME" + DEST_MODULE_LOCATION[0]="/kernel/drivers/video" +-MAKE[0]="make module KERNEL_UNAME=${kernelver}" ++MAKE[0]="make -j$num_cpu_cores module KERNEL_UNAME=${kernelver}" + CLEAN="make clean" + AUTOINSTALL="yes" +diff -Naur a/kernel/Makefile b/kernel/Makefile +--- a/kernel/Makefile 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/Makefile 2023-03-04 13:26:40.787675335 +0100 +@@ -70,11 +70,11 @@ + MODULE_GLUE_OBJS := $(patsubst %.c,%.o,nv-frontend.c) + $(MODULE_NAME)-objs := $(MODULE_GLUE_OBJS) + else +- MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c) ++ MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c nvidia-drm-linux.c nvidia-drm-gem.c nvidia-drm-helper.c nvidia-drm-gem-user-memory.c) + $(MODULE_NAME)-objs := $(CORE_OBJS) $(MODULE_GLUE_OBJS) + endif + else +- MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c) $(patsubst %.c,%.o,nv-frontend.c) ++ MODULE_GLUE_OBJS := $(patsubst %.c,%.o, nv.c nv-acpi.c nv-chrdev.c nv-cray.c nv-dma.c nv-drm.c nv-gvi.c nv-i2c.c nv-mempool.c nv-mmap.c nv-p2p.c nv-pat.c nv-procfs.c nv-usermap.c nv-vm.c nv-vtophys.c os-interface.c os-mlock.c os-pci.c os-registry.c os-smp.c os-usermap.c nv_uvm_interface.c nvidia-drm-linux.c nvidia-drm-gem.c nvidia-drm-helper.c nvidia-drm-gem-user-memory.c) $(patsubst %.c,%.o,nv-frontend.c) + $(MODULE_NAME)-objs := $(CORE_OBJS) $(MODULE_GLUE_OBJS) + endif + +@@ -168,7 +168,7 @@ + EXTRA_CFLAGS += -DNV_BUILD_MODULE_INSTANCES=0 + endif + +-EXTRA_CFLAGS += -UDEBUG -U_DEBUG -DNDEBUG ++EXTRA_CFLAGS += -UDEBUG -U_DEBUG -DNDEBUG -DNV_KERNEL_INTERFACE_LAYER + + # + # Include common definitions; we rely on the definition of the source path to +@@ -178,6 +178,7 @@ + + src ?= . + include $(src)/nvidia-modules-common.mk ++include $(src)/conftest.Kbuild + + # + # Generate multiple targets at runtime depending on the items present in +diff -Naur a/kernel/nv-acpi.c b/kernel/nv-acpi.c +--- a/kernel/nv-acpi.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-acpi.c 2023-03-04 13:26:40.796675128 +0100 +@@ -25,6 +25,8 @@ + + #if !defined(NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT) || (NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT == 2) + static int nv_acpi_remove_two_args(struct acpi_device *device, int type); ++#elif LINUX_VERSION_CODE >= KERNEL_VERSION(6, 2, 0) ++static void nv_acpi_remove_one_arg(struct acpi_device *device); + #else + static int nv_acpi_remove_one_arg(struct acpi_device *device); + #endif +@@ -190,9 +192,9 @@ + union acpi_object control_argument_0 = { ACPI_TYPE_INTEGER }; + struct acpi_object_list control_argument_list = { 0, NULL }; + nv_stack_t *sp = NULL; +- struct list_head *node, *next; + nv_acpi_integer_t device_id = 0; + int device_counter = 0; ++ acpi_handle handle = NULL; + + NV_KMEM_CACHE_ALLOC_STACK(sp); + if (sp == NULL) +@@ -220,13 +222,12 @@ + + // grab handles to all the important nodes representing devices + +- list_for_each_safe(node, next, &device->children) ++ do + { +- struct acpi_device *dev = +- list_entry(node, struct acpi_device, node); +- +- if (!dev) +- continue; ++ status = acpi_get_next_object(ACPI_TYPE_DEVICE, device->handle, ++ handle, &handle); ++ if (ACPI_FAILURE(status) || (handle == NULL)) ++ break; + + if (device_counter == NV_MAXNUM_DISPLAY_DEVICES) + { +@@ -237,7 +238,7 @@ + } + + status = +- acpi_evaluate_integer(dev->handle, "_ADR", NULL, &device_id); ++ acpi_evaluate_integer(handle, "_ADR", NULL, &device_id); + if (ACPI_FAILURE(status)) + /* Couldnt query device_id for this device */ + continue; +@@ -256,11 +257,11 @@ + } + + pNvAcpiObject->pNvVideo[device_counter].dev_id = device_id; +- pNvAcpiObject->pNvVideo[device_counter].dev_handle = dev->handle; ++ pNvAcpiObject->pNvVideo[device_counter].dev_handle = handle; + + device_counter++; + +- } ++ } while (handle != NULL); + + // arg 0, bits 1:0, 0 = enable events + control_argument_0.integer.type = ACPI_TYPE_INTEGER; +@@ -298,6 +299,8 @@ + + #if !defined(NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT) || (NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT == 2) + static int nv_acpi_remove_two_args(struct acpi_device *device, int type) ++#elif LINUX_VERSION_CODE >= KERNEL_VERSION(6, 2, 0) ++static void nv_acpi_remove_one_arg(struct acpi_device *device) + #else + static int nv_acpi_remove_one_arg(struct acpi_device *device) + #endif +@@ -350,7 +353,9 @@ + device->driver_data = NULL; + } + ++#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 2, 0) || !defined(NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT) || (NV_ACPI_DEVICE_OPS_REMOVE_ARGUMENT_COUNT == 2) + return status; ++#endif + } + + static void nv_acpi_event(acpi_handle handle, u32 event_type, void *data) +@@ -556,9 +561,11 @@ + + void NV_API_CALL nv_acpi_methods_init(NvU32 *handlesPresent) + { ++#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) + struct acpi_device *device = NULL; + RM_STATUS rmStatus; + int retVal = -1; ++#endif + + + if (!handlesPresent) // Caller passed us invalid pointer. +@@ -570,6 +577,7 @@ + NV_ACPI_WALK_NAMESPACE(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, + ACPI_UINT32_MAX, nv_acpi_find_methods, NULL, NULL); + ++#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) + if (nvif_handle) + { + *handlesPresent = NV_ACPI_NVIF_HANDLE_PRESENT; +@@ -596,6 +604,7 @@ + + } while (0); + } ++#endif + + if (wmmx_handle) + *handlesPresent = *handlesPresent | NV_ACPI_WMMX_HANDLE_PRESENT; +@@ -651,10 +660,12 @@ + + if (nvif_parent_gpu_handle == NULL) + return; +- ++#if defined(NV_ACPI_BUS_GET_DEVICE_PRESENT) + acpi_bus_get_device(nvif_parent_gpu_handle, &device); + + nv_uninstall_notifier(device, nv_acpi_event); ++#endif ++ + nvif_parent_gpu_handle = NULL; + + return; +@@ -1195,16 +1206,15 @@ + ) + { + acpi_status status; +- struct acpi_device *device = NULL; + struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; + union acpi_object *ddc; + union acpi_object ddc_arg0 = { ACPI_TYPE_INTEGER }; + struct acpi_object_list input = { 1, &ddc_arg0 }; +- struct list_head *node, *next; + nv_acpi_integer_t device_id = 0; + NvU32 i; + acpi_handle dev_handle = NULL; + acpi_handle lcd_dev_handle = NULL; ++ acpi_handle handle = NULL; + + if (!nv_acpi_get_device_handle(nv, &dev_handle)) + return RM_ERR_NOT_SUPPORTED; +@@ -1212,11 +1222,6 @@ + if (!dev_handle) + return RM_ERR_INVALID_ARGUMENT; + +- status = acpi_bus_get_device(dev_handle, &device); +- +- if (ACPI_FAILURE(status) || !device) +- return RM_ERR_INVALID_ARGUMENT; +- + if (!NV_MAY_SLEEP()) + { + #if defined(DEBUG) +@@ -1227,15 +1232,15 @@ + return RM_ERR_NOT_SUPPORTED; + } + +- list_for_each_safe(node, next, &device->children) ++ while (lcd_dev_handle == NULL) + { +- struct acpi_device *dev = +- list_entry(node, struct acpi_device, node); ++ status = acpi_get_next_object(ACPI_TYPE_DEVICE, dev_handle, ++ handle, &handle); ++ if (ACPI_FAILURE(status) || (handle == NULL)) ++ break; + +- if (!dev) +- continue; ++ status = acpi_evaluate_integer(handle, "_ADR", NULL, &device_id); + +- status = acpi_evaluate_integer(dev->handle, "_ADR", NULL, &device_id); + if (ACPI_FAILURE(status)) + /* Couldnt query device_id for this device */ + continue; +@@ -1244,7 +1249,7 @@ + + if ((device_id == 0x0110) || (device_id == 0x0118) || (device_id == 0x0400)) /* Only for an LCD*/ + { +- lcd_dev_handle = dev->handle; ++ lcd_dev_handle = handle; + nv_printf(NV_DBG_INFO, "NVRM: %s Found LCD: %x\n", __FUNCTION__, device_id); + break; + } +diff -Naur a/kernel/nv.c b/kernel/nv.c +--- a/kernel/nv.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv.c 2023-03-04 13:26:40.802674990 +0100 +@@ -752,7 +752,7 @@ + NV_SPIN_LOCK_INIT(&km_lock); + #endif + +- NV_KMEM_CACHE_CREATE(nv_stack_t_cache, NV_STACK_CACHE_STR, nv_stack_t); ++ NV_KMEM_CACHE_CREATE_USERCOPY(nv_stack_t_cache, NV_STACK_CACHE_STR, nv_stack_t); + if (nv_stack_t_cache == NULL) + { + nv_printf(NV_DBG_ERRORS, "NVRM: stack cache allocation failed!\n"); +@@ -2785,7 +2785,11 @@ + + #if defined(CONFIG_VGA_ARB) + #if defined(VGA_DEFAULT_DEVICE) ++#if defined(NV_VGA_TRYGET_PRESENT) + vga_tryget(VGA_DEFAULT_DEVICE, VGA_RSRC_LEGACY_MASK); ++#else ++ vga_get(VGA_DEFAULT_DEVICE, VGA_RSRC_LEGACY_MASK, 0); ++#endif + #endif + vga_set_legacy_decoding(dev, VGA_RSRC_NONE); + #endif +diff -Naur a/kernel/nv-dma.c b/kernel/nv-dma.c +--- a/kernel/nv-dma.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-dma.c 2023-03-04 13:26:40.796675128 +0100 +@@ -136,10 +136,17 @@ + return status; + } + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ++ dma_map->sg_map_count = dma_map_sg(&dma_map->dev->dev, ++ NV_DMA_MAP_SCATTERLIST(dma_map), ++ NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), ++ DMA_BIDIRECTIONAL); ++#else + dma_map->sg_map_count = pci_map_sg(dma_map->dev, + NV_DMA_MAP_SCATTERLIST(dma_map), + NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), + PCI_DMA_BIDIRECTIONAL); ++#endif + if (dma_map->sg_map_count == 0) + { + nv_printf(NV_DBG_ERRORS, +@@ -211,8 +218,13 @@ + + if (dma_map->sg_map_count != 0) + { ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ++ dma_unmap_sg(&dma_map->dev->dev, NV_DMA_MAP_SCATTERLIST(dma_map), ++ NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), DMA_BIDIRECTIONAL); ++#else + pci_unmap_sg(dma_map->dev, NV_DMA_MAP_SCATTERLIST(dma_map), + NV_DMA_MAP_SCATTERLIST_LENGTH(dma_map), PCI_DMA_BIDIRECTIONAL); ++#endif + } + + *priv = dma_map->user_pages; +diff -Naur a/kernel/nv-drm.c b/kernel/nv-drm.c +--- a/kernel/nv-drm.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-drm.c 2023-03-04 13:26:40.797675105 +0100 +@@ -23,6 +23,11 @@ + #include <linux/file.h> + #endif + ++#include <nvidia-drm-priv.h> ++#include <nvidia-drm-ioctl.h> ++#include <nvidia-drm-gem-user-memory.h> ++#include <nvidia-drm-helper.h> ++ + #if defined(NV_DRM_DRM_DRV_H_PRESENT) + #include <drm/drm_drv.h> + #endif +@@ -55,6 +60,8 @@ + #define nv_drm_pci_exit drm_pci_exit + #endif + ++static struct nv_drm_device *dev_list = NULL; ++ + extern nv_linux_state_t *nv_linux_devices; + + struct nv_gem_object { +@@ -62,20 +69,35 @@ + struct page **pages; + }; + ++#if !defined(NV_DRM_DEVICE_HAS_PDEV) ++#include <drm/drm_legacy.h> ++struct nv_drm_extra_priv_data { ++ struct pci_dev *pdev; ++ struct drm_agp_head *agp; ++}; ++#endif ++ + static int nv_drm_load( + struct drm_device *dev, + unsigned long flags + ) + { + nv_linux_state_t *nvl; ++#if !defined(NV_DRM_DEVICE_HAS_PDEV) ++ struct nv_drm_extra_priv_data *extra = dev->dev_private; ++#endif + + for (nvl = nv_linux_devices; nvl != NULL; nvl = nvl->next) + { +- if (nvl->dev == dev->pdev) +- { +- nvl->drm = dev; +- return 0; +- } ++#if defined(NV_DRM_DEVICE_HAS_PDEV) ++ if (nvl->dev == dev->pdev) ++#else ++ if (nvl->dev == extra->pdev) ++#endif ++ { ++ nvl->drm = dev; ++ return 0; ++ } + } + + return -ENODEV; +@@ -92,11 +114,18 @@ + ) + { + nv_linux_state_t *nvl; ++#if !defined(NV_DRM_DEVICE_HAS_PDEV) ++ struct nv_drm_extra_priv_data *extra = dev->dev_private; ++#endif + + for (nvl = nv_linux_devices; nvl != NULL; nvl = nvl->next) + { +- if (nvl->dev == dev->pdev) +- { ++#if defined(NV_DRM_DEVICE_HAS_PDEV) ++ if (nvl->dev == dev->pdev) ++#else ++ if (nvl->dev == extra->pdev) ++#endif ++ { + BUG_ON(nvl->drm != dev); + nvl->drm = NULL; + return 0; +@@ -131,32 +160,49 @@ + NV_KFREE(nv_obj, sizeof(*nv_obj)); + } + +-static struct sg_table* nv_gem_prime_get_sg_table( +- struct drm_gem_object *obj +-) ++static int nv_drm_get_dev_info_ioctl(struct drm_device *dev, ++ void *data, struct drm_file *filep) + { +- struct nv_gem_object *nv_obj = container_of(obj, struct nv_gem_object, base); +- int page_count = obj->size >> PAGE_SHIFT; ++ struct nv_drm_device *nv_dev = to_nv_device(dev); ++ struct drm_nvidia_get_dev_info_params *params = data; + +- return drm_prime_pages_to_sg(nv_obj->pages, page_count); +-} ++ if (dev->primary == NULL) { ++ return -ENOENT; ++ } + +-static void* nv_gem_prime_vmap( +- struct drm_gem_object *obj +-) +-{ +- struct nv_gem_object *nv_obj = container_of(obj, struct nv_gem_object, base); +- int page_count = obj->size >> PAGE_SHIFT; ++ params->gpu_id = nv_dev->gpu_info.gpu_id; ++ params->primary_index = dev->primary->index; + +- return vmap(nv_obj->pages, page_count, VM_USERMAP, PAGE_KERNEL); ++ return 0; + } + +-static void nv_gem_prime_vunmap( +- struct drm_gem_object *obj, +- void *virtual +-) +-{ +- vunmap(virtual); ++static ++int nv_drm_get_client_capability_ioctl(struct drm_device *dev, ++ void *data, struct drm_file *filep) ++{ ++ struct drm_nvidia_get_client_capability_params *params = data; ++ ++ switch (params->capability) { ++#if defined(DRM_CLIENT_CAP_STEREO_3D) ++ case DRM_CLIENT_CAP_STEREO_3D: ++ params->value = filep->stereo_allowed; ++ break; ++#endif ++#if defined(DRM_CLIENT_CAP_UNIVERSAL_PLANES) ++ case DRM_CLIENT_CAP_UNIVERSAL_PLANES: ++ params->value = filep->universal_planes; ++ break; ++#endif ++#if defined(DRM_CLIENT_CAP_ATOMIC) ++ case DRM_CLIENT_CAP_ATOMIC: ++ params->value = filep->atomic; ++ break; ++#endif ++ default: ++ return -EINVAL; ++ } ++ ++ return 0; + } + + static const struct file_operations nv_drm_fops = { +@@ -170,6 +216,43 @@ + .llseek = noop_llseek, + }; + ++static const struct drm_ioctl_desc nv_drm_ioctls[] = { ++// #if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) ++// DRM_IOCTL_DEF_DRV(NVIDIA_GEM_IMPORT_NVKMS_MEMORY, ++// nv_drm_gem_import_nvkms_memory_ioctl, ++// DRM_UNLOCKED), ++// #endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */ ++// ++ DRM_IOCTL_DEF_DRV(NVIDIA_GEM_IMPORT_USERSPACE_MEMORY, ++ nv_drm_gem_import_userspace_memory_ioctl, ++ DRM_RENDER_ALLOW|DRM_UNLOCKED), ++ DRM_IOCTL_DEF_DRV(NVIDIA_GET_DEV_INFO, ++ nv_drm_get_dev_info_ioctl, ++ DRM_RENDER_ALLOW|DRM_UNLOCKED), ++ ++// #if defined(NV_DRM_FENCE_AVAILABLE) ++// DRM_IOCTL_DEF_DRV(NVIDIA_FENCE_SUPPORTED, ++// nv_drm_fence_supported_ioctl, ++// DRM_RENDER_ALLOW|DRM_UNLOCKED), ++// DRM_IOCTL_DEF_DRV(NVIDIA_FENCE_CONTEXT_CREATE, ++// nv_drm_fence_context_create_ioctl, ++// DRM_RENDER_ALLOW|DRM_UNLOCKED), ++// DRM_IOCTL_DEF_DRV(NVIDIA_GEM_FENCE_ATTACH, ++// nv_drm_gem_fence_attach_ioctl, ++// DRM_RENDER_ALLOW|DRM_UNLOCKED), ++// #endif ++ ++ DRM_IOCTL_DEF_DRV(NVIDIA_GET_CLIENT_CAPABILITY, ++ nv_drm_get_client_capability_ioctl, ++ 0), ++// #if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) ++// DRM_IOCTL_DEF_DRV(NVIDIA_GET_CRTC_CRC32, ++// nv_drm_get_crtc_crc32_ioctl, ++// DRM_RENDER_ALLOW|DRM_UNLOCKED), ++// #endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */ ++}; ++ ++ + static struct drm_driver nv_drm_driver = { + + .driver_features = DRIVER_GEM +@@ -188,13 +271,24 @@ + .set_busid = drm_pci_set_busid, + #endif + ++#if defined(NV_DRM_DRIVER_HAS_GEM_FREE_OBJECT) + .gem_free_object = nv_gem_free, ++#endif ++ ++ .ioctls = nv_drm_ioctls, ++ .num_ioctls = ARRAY_SIZE(nv_drm_ioctls), + + .prime_handle_to_fd = drm_gem_prime_handle_to_fd, +- .gem_prime_export = drm_gem_prime_export, +- .gem_prime_get_sg_table = nv_gem_prime_get_sg_table, +- .gem_prime_vmap = nv_gem_prime_vmap, +- .gem_prime_vunmap = nv_gem_prime_vunmap, ++#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_CALLBACKS) ++ .gem_prime_export = nv_drm_gem_prime_export, ++ .gem_prime_get_sg_table = nv_drm_gem_prime_get_sg_table, ++ .gem_prime_vmap = nv_drm_gem_prime_vmap, ++ .gem_prime_vunmap = nv_drm_gem_prime_vunmap, ++#endif ++ ++#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ) ++ .gem_prime_res_obj = nv_drm_gem_prime_res_obj, ++#endif + + .name = "nvidia-drm", + .desc = "NVIDIA DRM driver", +@@ -202,7 +296,206 @@ + .major = 0, + .minor = 0, + .patchlevel = 0, ++ ++#if defined(NV_DRM_DRIVER_HAS_DEVICE_LIST) ++ .device_list = LIST_HEAD_INIT(nv_drm_driver.device_list), ++#elif defined(NV_DRM_DRIVER_HAS_LEGACY_DEV_LIST) ++ .legacy_dev_list = LIST_HEAD_INIT(nv_drm_driver.legacy_dev_list), ++#endif + }; ++ ++/*! ++ * Enumerate the available physical GPUs that can be used with NVKMS. ++ * ++ * \param [out] gpuInfo The information of the enumerated GPUs. ++ * It is an array of NVIDIA_MAX_GPUS elements. ++ * ++ * \return Count of enumerated gpus. ++ */ ++ ++/* ++ * Implemented based on code from drm_legacy_pci_{init,exit} ++ * Extracted from tag: v5.6.3, file: drivers/gpu/drm/drm_pci.c ++ */ ++static NvU32 nvKmsenumerateGpus(nv_gpu_info_t *gpuInfo, struct drm_driver *driver, struct pci_driver *pdriver) ++{ ++ NvU32 gpu_count = 0; ++ ++ struct pci_dev *pdev = NULL; ++ const struct pci_device_id *pid; ++ int i; ++ ++ DRM_DEBUG("\n"); ++ ++ for (i = 0; pdriver->id_table[i].vendor != 0; i++) { ++ pid = &pdriver->id_table[i]; ++ ++ /* Loop around setting up a DRM device for each PCI device ++ * matching our ID and device class. If we had the internal ++ * function that pci_get_subsys and pci_get_class used, we'd ++ * be able to just pass pid in instead of doing a two-stage ++ * thing. ++ */ ++ pdev = NULL; ++ while ((pdev = ++ pci_get_subsys(pid->vendor, pid->device, pid->subvendor, ++ pid->subdevice, pdev)) != NULL) { ++ ++ if ((pdev->class & pid->class_mask) != pid->class) ++ continue; ++ ++ /* stealth mode requires a manual probe */ ++ pci_dev_get(pdev); ++ ++ gpuInfo[i].gpu_id = pid->device; ++ gpuInfo[i].pci_info.domain = pci_domain_nr(pdev->bus); ++ gpuInfo[i].pci_info.bus = pdev->bus->number; ++ gpuInfo[i].pci_info.slot = PCI_SLOT(pdev->devfn); ++ gpuInfo[i].pci_info.function = PCI_FUNC(pdev->devfn); ++ gpuInfo[i].os_dev_ptr = pdev; ++ gpu_count += 1; ++ } ++ } ++ return gpu_count; ++} ++ ++/* ++ * Helper function for allocate/register DRM device for given NVIDIA GPU ID. ++ */ ++static void nv_drm_register_drm_device(const nv_gpu_info_t *gpu_info) ++{ ++ struct nv_drm_device *nv_dev = NULL; ++ struct drm_device *dev = NULL; ++ struct nv_drm_extra_priv_data *extra; ++ struct pci_dev *pdev = gpu_info->os_dev_ptr; ++ ++ DRM_DEBUG( ++ "Registering device for NVIDIA GPU ID 0x08%x", ++ gpu_info->gpu_id); ++ ++ /* Allocate NVIDIA-DRM device */ ++ ++ nv_dev = nv_drm_calloc(1, sizeof(*nv_dev)); ++ ++ if (nv_dev == NULL) { ++ NV_DRM_LOG_ERR( ++ "Failed to allocate memmory for NVIDIA-DRM device object"); ++ return; ++ } ++ ++ nv_dev->gpu_info = *gpu_info; ++ ++#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) ++ mutex_init(&nv_dev->lock); ++#endif ++ ++ /* Allocate DRM device */ ++ ++ dev = drm_dev_alloc(&nv_drm_driver, &pdev->dev); ++ ++ if (dev == NULL) { ++ NV_DRM_DEV_LOG_ERR(nv_dev, "Failed to allocate device"); ++ goto failed_drm_alloc; ++ } ++ ++ dev->dev_private = nv_dev; ++ nv_dev->dev = dev; ++ ++#if defined(NV_DRM_DEVICE_HAS_PDEV) ++ dev->pdev = pdev; ++#else ++ extra = kzalloc(sizeof(*extra), GFP_KERNEL); ++ extra->pdev = pdev; ++ dev->dev_private = extra; ++#endif ++ ++ /* Register DRM device to DRM sub-system */ ++ ++ if (drm_dev_register(dev, 0) != 0) { ++ NV_DRM_DEV_LOG_ERR(nv_dev, "Failed to register device"); ++ goto failed_drm_register; ++ } ++ ++ /* Add NVIDIA-DRM device into list */ ++ ++ nv_dev->next = dev_list; ++ dev_list = nv_dev; ++ ++ return; /* Success */ ++ ++failed_drm_register: ++ ++ nv_drm_dev_free(dev); ++ ++failed_drm_alloc: ++ ++ nv_drm_free(nv_dev); ++} ++ ++/* ++ * Enumerate NVIDIA GPUs and allocate/register DRM device for each of them. ++ */ ++int nv_drm_probe_devices(struct drm_driver *driver, struct pci_driver *pdriver) ++{ ++ nv_gpu_info_t *gpu_info = NULL; ++ NvU32 gpu_count = 0; ++ NvU32 i; ++ ++ int ret = 0; ++ ++// nv_drm_update_drm_driver_features(); ++ ++ /* Enumerate NVIDIA GPUs */ ++ ++ gpu_info = nv_drm_calloc(NV_MAX_GPUS, sizeof(*gpu_info)); ++ ++ if (gpu_info == NULL) { ++ ret = -ENOMEM; ++ ++ NV_DRM_LOG_ERR("Failed to allocate gpu ids arrays"); ++ goto done; ++ } ++ ++ gpu_count = nvKmsenumerateGpus(gpu_info, driver, pdriver); ++// gpu_count = nvKms->enumerateGpus(gpu_info); ++ ++ if (gpu_count == 0) { ++ NV_DRM_LOG_INFO("Not found NVIDIA GPUs"); ++ goto done; ++ } ++ ++ WARN_ON(gpu_count > NV_MAX_GPUS); ++ ++ /* Register DRM device for each NVIDIA GPU */ ++ ++ for (i = 0; i < gpu_count; i++) { ++ nv_drm_register_drm_device(&gpu_info[i]); ++ } ++ ++done: ++ ++ nv_drm_free(gpu_info); ++ ++ return ret; ++} ++ ++/* ++ * Unregister all NVIDIA DRM devices. ++ */ ++void nv_drm_remove_devices(void) ++{ ++ while (dev_list != NULL) { ++ struct nv_drm_device *next = dev_list->next; ++ ++ drm_dev_unregister(dev_list->dev); ++ nv_drm_dev_free(dev_list->dev); ++ ++ nv_drm_free(dev_list); ++ ++ dev_list = next; ++ } ++} ++ + #endif /* defined(NV_DRM_AVAILABLE) */ + + int __init nv_drm_init( +@@ -211,7 +504,7 @@ + { + int ret = 0; + #if defined(NV_DRM_AVAILABLE) +- ret = nv_drm_pci_init(&nv_drm_driver, pci_driver); ++ ret = nv_drm_probe_devices(&nv_drm_driver, pci_driver); + #endif + return ret; + } +@@ -221,7 +514,7 @@ + ) + { + #if defined(NV_DRM_AVAILABLE) +- nv_drm_pci_exit(&nv_drm_driver, pci_driver); ++ nv_drm_remove_devices(); + #endif + } + +@@ -282,9 +575,15 @@ + goto done; + } + +-#if defined(NV_DRM_GEM_OBJECT_PUT_UNLOCKED_PRESENT) ++#if defined(NV_DRM_GEM_OBJECT_GET_PRESENT) ++ ++#if defined(NV_DRM_GEM_OBJECT_PUT_UNLOCK_PRESENT) + drm_gem_object_put_unlocked(&nv_obj->base); + #else ++ drm_gem_object_put(&nv_obj->base); ++#endif + - esac ++#else + drm_gem_object_unreference_unlocked(&nv_obj->base); + #endif + +diff -Naur a/kernel/nv-frontend.c b/kernel/nv-frontend.c +--- a/kernel/nv-frontend.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-frontend.c 2023-03-04 13:26:40.798675082 +0100 +@@ -8,6 +8,7 @@ + * _NVRM_COPYRIGHT_END_ + */ + ++#include "conftest.h" + #include "nv-misc.h" + #include "os-interface.h" + #include "nv-linux.h" +@@ -15,7 +16,7 @@ + #include "nv-frontend.h" + + #if defined(MODULE_LICENSE) +-MODULE_LICENSE("NVIDIA"); ++MODULE_LICENSE("GPL"); + #endif + #if defined(MODULE_INFO) + MODULE_INFO(supported, "external"); +@@ -377,7 +378,7 @@ + #if (NV_BUILD_MODULE_INSTANCES != 0) + #if defined(CONFIG_PROC_FS) + if ((nv_num_instances == 0) && (nv_proc_topdir != NULL)) +- NV_REMOVE_PROCE_ENTRY(nv_proc_topdir); ++ NV_REMOVE_PROC_ENTRY(nv_proc_topdir); + #endif + #else + nvidia_exit_module(); diff -Naur a/kernel/nv-gpu-info.h b/kernel/nv-gpu-info.h --- a/kernel/nv-gpu-info.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nv-gpu-info.h 2022-06-05 13:18:33.949571878 +0200 ++++ b/kernel/nv-gpu-info.h 2023-03-04 13:26:25.830020170 +0100 @@ -0,0 +1,31 @@ +/* _NVRM_COPYRIGHT_BEGIN_ + * @@ -3880,9 +5013,21 @@ diff -Naur a/kernel/nv-gpu-info.h b/kernel/nv-gpu-info.h +#define NV_MAX_GPUS 32 + +#endif /* _NV_GPU_INFO_H_ */ +diff -Naur a/kernel/nv.h b/kernel/nv.h +--- a/kernel/nv.h 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv.h 2023-03-04 13:26:40.803674966 +0100 +@@ -13,7 +13,7 @@ + #define _NV_H_ + + #include <nvtypes.h> +-#include <stdarg.h> ++#include "nv_stdarg.h" + + #if !defined(NV_MIN) + #define NV_MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b)) diff -Naur a/kernel/nvidia-dma-fence-helper.h b/kernel/nvidia-dma-fence-helper.h --- a/kernel/nvidia-dma-fence-helper.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-dma-fence-helper.h 2022-06-05 13:18:33.951571834 +0200 ++++ b/kernel/nvidia-dma-fence-helper.h 2023-03-04 13:26:25.832020124 +0100 @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. @@ -4007,8 +5152,8 @@ diff -Naur a/kernel/nvidia-dma-fence-helper.h b/kernel/nvidia-dma-fence-helper.h +#endif /* __NVIDIA_DMA_FENCE_HELPER_H__ */ diff -Naur a/kernel/nvidia-dma-resv-helper.h b/kernel/nvidia-dma-resv-helper.h --- a/kernel/nvidia-dma-resv-helper.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-dma-resv-helper.h 2022-06-05 13:18:33.951571834 +0200 -@@ -0,0 +1,80 @@ ++++ b/kernel/nvidia-dma-resv-helper.h 2023-03-04 13:26:25.833020101 +0100 +@@ -0,0 +1,126 @@ +/* + * Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved. + * @@ -4076,11 +5221,57 @@ diff -Naur a/kernel/nvidia-dma-resv-helper.h b/kernel/nvidia-dma-resv-helper.h +#endif +} + ++static inline void nv_dma_resv_lock(nv_dma_resv_t *obj, ++ struct ww_acquire_ctx *ctx) ++{ ++#if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ dma_resv_lock(obj, ctx); ++#else ++ ww_mutex_lock(&obj->lock, ctx); ++#endif ++} ++ ++static inline void nv_dma_resv_unlock(nv_dma_resv_t *obj) ++{ ++#if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ dma_resv_unlock(obj); ++#else ++ ww_mutex_unlock(&obj->lock); ++#endif ++} ++ ++static inline int nv_dma_resv_reserve_fences(nv_dma_resv_t *obj, ++ unsigned int num_fences, ++ NvBool shared) ++{ ++#if defined(NV_DMA_RESV_RESERVE_FENCES_PRESENT) ++ return dma_resv_reserve_fences(obj, num_fences); ++#else ++ if (shared) { ++#if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++ return dma_resv_reserve_shared(obj, num_fences); ++#elif defined(NV_RESERVATION_OBJECT_RESERVE_SHARED_HAS_NUM_FENCES_ARG) ++ return reservation_object_reserve_shared(obj, num_fences); ++#else ++ unsigned int i; ++ for (i = 0; i < num_fences; i++) { ++ reservation_object_reserve_shared(obj); ++ } ++#endif ++ } ++ return 0; ++#endif ++} ++ +static inline void nv_dma_resv_add_excl_fence(nv_dma_resv_t *obj, + nv_dma_fence_t *fence) +{ +#if defined(NV_LINUX_DMA_RESV_H_PRESENT) ++#if defined(NV_DMA_RESV_ADD_FENCE_PRESENT) ++ dma_resv_add_fence(obj, fence, DMA_RESV_USAGE_WRITE); ++#else + dma_resv_add_excl_fence(obj, fence); ++#endif +#else + reservation_object_add_excl_fence(obj, fence); +#endif @@ -4091,7 +5282,7 @@ diff -Naur a/kernel/nvidia-dma-resv-helper.h b/kernel/nvidia-dma-resv-helper.h +#endif /* __NVIDIA_DMA_RESV_HELPER_H__ */ diff -Naur a/kernel/nvidia-drm-conftest.h b/kernel/nvidia-drm-conftest.h --- a/kernel/nvidia-drm-conftest.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-conftest.h 2022-06-05 13:18:33.952571813 +0200 ++++ b/kernel/nvidia-drm-conftest.h 2023-03-04 13:26:40.803674966 +0100 @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. @@ -4149,7 +5340,7 @@ diff -Naur a/kernel/nvidia-drm-conftest.h b/kernel/nvidia-drm-conftest.h + +#endif + -+#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ) || \ ++#if defined(NV_DRM_DRIVER_HAS_GEM_PRIME_RES_OBJ) && \ + defined(NV_DRM_GEM_OBJECT_HAS_RESV) +#define NV_DRM_FENCE_AVAILABLE +#else @@ -4159,7 +5350,7 @@ diff -Naur a/kernel/nvidia-drm-conftest.h b/kernel/nvidia-drm-conftest.h +#endif /* defined(__NVIDIA_DRM_CONFTEST_H__) */ diff -Naur a/kernel/nvidia-drm-gem.c b/kernel/nvidia-drm-gem.c --- a/kernel/nvidia-drm-gem.c 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-gem.c 2022-06-05 13:18:33.953571791 +0200 ++++ b/kernel/nvidia-drm-gem.c 2023-03-04 13:26:40.804674943 +0100 @@ -0,0 +1,204 @@ +/* + * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. @@ -4189,10 +5380,10 @@ diff -Naur a/kernel/nvidia-drm-gem.c b/kernel/nvidia-drm-gem.c + +#include "nvidia-drm-priv.h" +#include "nvidia-drm-ioctl.h" -+#include "nvidia-drm-prime-fence.h" ++// #include "nvidia-drm-prime-fence.h" +#include "nvidia-drm-gem.h" +#include "nvidia-dma-resv-helper.h" -+#include "nvidia-drm-gem-nvkms-memory.h" ++// #include "nvidia-drm-gem-nvkms-memory.h" + +#if defined(NV_DRM_DRM_PRIME_H_PRESENT) +#include <drm/drm_prime.h> @@ -4262,9 +5453,9 @@ diff -Naur a/kernel/nvidia-drm-gem.c b/kernel/nvidia-drm-gem.c + .vunmap = nv_drm_gem_prime_vunmap, +#endif + -+#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) -+ .vm_ops = &nv_drm_gem_vma_ops, -+#endif ++// #if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) ++// .vm_ops = &nv_drm_gem_vma_ops, ++// #endif + +#endif +}; @@ -4367,7 +5558,7 @@ diff -Naur a/kernel/nvidia-drm-gem.c b/kernel/nvidia-drm-gem.c +#endif /* NV_DRM_AVAILABLE */ diff -Naur a/kernel/nvidia-drm-gem.h b/kernel/nvidia-drm-gem.h --- a/kernel/nvidia-drm-gem.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-gem.h 2022-06-05 13:18:33.953571791 +0200 ++++ b/kernel/nvidia-drm-gem.h 2023-03-04 13:26:25.836020032 +0100 @@ -0,0 +1,198 @@ +/* + * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. @@ -4569,7 +5760,7 @@ diff -Naur a/kernel/nvidia-drm-gem.h b/kernel/nvidia-drm-gem.h +#endif /* __NVIDIA_DRM_GEM_H__ */ diff -Naur a/kernel/nvidia-drm-gem-user-memory.c b/kernel/nvidia-drm-gem-user-memory.c --- a/kernel/nvidia-drm-gem-user-memory.c 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-gem-user-memory.c 2022-06-05 13:18:33.952571813 +0200 ++++ b/kernel/nvidia-drm-gem-user-memory.c 2023-03-04 13:26:25.834020078 +0100 @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. @@ -4712,7 +5903,7 @@ diff -Naur a/kernel/nvidia-drm-gem-user-memory.c b/kernel/nvidia-drm-gem-user-me +#endif diff -Naur a/kernel/nvidia-drm-gem-user-memory.h b/kernel/nvidia-drm-gem-user-memory.h --- a/kernel/nvidia-drm-gem-user-memory.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-gem-user-memory.h 2022-06-05 13:18:33.953571791 +0200 ++++ b/kernel/nvidia-drm-gem-user-memory.h 2023-03-04 13:26:25.835020055 +0100 @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. @@ -4769,8 +5960,8 @@ diff -Naur a/kernel/nvidia-drm-gem-user-memory.h b/kernel/nvidia-drm-gem-user-me +#endif /* __NVIDIA_DRM_GEM_USER_MEMORY_H__ */ diff -Naur a/kernel/nvidia-drm-helper.c b/kernel/nvidia-drm-helper.c --- a/kernel/nvidia-drm-helper.c 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-helper.c 2022-06-05 13:18:33.954571769 +0200 -@@ -0,0 +1,189 @@ ++++ b/kernel/nvidia-drm-helper.c 2023-03-04 13:26:40.804674943 +0100 +@@ -0,0 +1,202 @@ +/* + * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. + * @@ -4802,7 +5993,7 @@ diff -Naur a/kernel/nvidia-drm-helper.c b/kernel/nvidia-drm-helper.c + +#include "nvidia-drm-helper.h" + -+#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) ++#if defined(NV_DRM_ATOMIC_MODESET_AVAILABLE) && FALSE + +#if defined(NV_DRM_DRMP_H_PRESENT) +#include <drm/drmP.h> @@ -4812,6 +6003,19 @@ diff -Naur a/kernel/nvidia-drm-helper.c b/kernel/nvidia-drm-helper.c +#include <drm/drm_atomic_uapi.h> +#endif + ++/* ++ * The inclusion of drm_framebuffer.h was removed from drm_crtc.h by commit ++ * 720cf96d8fecde29b72e1101f8a567a0ce99594f ("drm: Drop drm_framebuffer.h from ++ * drm_crtc.h") in linux-next, expected in v5.19-rc7. ++ * ++ * We only need drm_framebuffer.h for drm_framebuffer_put(), and it is always ++ * present (v4.9+) when drm_framebuffer_{put,get}() is present (v4.12+), so it ++ * is safe to unconditionally include it when drm_framebuffer_get() is present. ++ */ ++#if defined(NV_DRM_FRAMEBUFFER_GET_PRESENT) ++#include <drm/drm_framebuffer.h> ++#endif ++ +static void __nv_drm_framebuffer_put(struct drm_framebuffer *fb) +{ +#if defined(NV_DRM_FRAMEBUFFER_GET_PRESENT) @@ -4962,7 +6166,7 @@ diff -Naur a/kernel/nvidia-drm-helper.c b/kernel/nvidia-drm-helper.c +#endif /* NV_DRM_ATOMIC_MODESET_AVAILABLE */ diff -Naur a/kernel/nvidia-drm-helper.h b/kernel/nvidia-drm-helper.h --- a/kernel/nvidia-drm-helper.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-helper.h 2022-06-05 13:18:33.955571748 +0200 ++++ b/kernel/nvidia-drm-helper.h 2023-03-04 13:26:25.837020009 +0100 @@ -0,0 +1,441 @@ +/* + * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. @@ -5407,7 +6611,7 @@ diff -Naur a/kernel/nvidia-drm-helper.h b/kernel/nvidia-drm-helper.h +#endif /* __NVIDIA_DRM_HELPER_H__ */ diff -Naur a/kernel/nvidia-drm-ioctl.h b/kernel/nvidia-drm-ioctl.h --- a/kernel/nvidia-drm-ioctl.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-ioctl.h 2022-06-05 13:18:33.955571748 +0200 ++++ b/kernel/nvidia-drm-ioctl.h 2023-03-04 13:26:25.838019986 +0100 @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved. @@ -5546,8 +6750,8 @@ diff -Naur a/kernel/nvidia-drm-ioctl.h b/kernel/nvidia-drm-ioctl.h +#endif /* _UAPI_NVIDIA_DRM_IOCTL_H_ */ diff -Naur a/kernel/nvidia-drm-linux.c b/kernel/nvidia-drm-linux.c --- a/kernel/nvidia-drm-linux.c 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-linux.c 2022-06-05 13:18:33.955571748 +0200 -@@ -0,0 +1,185 @@ ++++ b/kernel/nvidia-drm-linux.c 2023-03-04 13:26:40.805674920 +0100 +@@ -0,0 +1,172 @@ +/* + * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. + * @@ -5575,7 +6779,6 @@ diff -Naur a/kernel/nvidia-drm-linux.c b/kernel/nvidia-drm-linux.c +#include <linux/err.h> + +#include "nvidia-drm-os-interface.h" -+#include "nvidia-drm.h" + +#include "nvidia-drm-conftest.h" + @@ -5597,6 +6800,16 @@ diff -Naur a/kernel/nvidia-drm-linux.c b/kernel/nvidia-drm-linux.c + +void *nv_drm_calloc(size_t nmemb, size_t size) +{ ++ ++ size_t total_size = nmemb * size; ++ // ++ // Check for overflow. ++ // ++ if ((nmemb != 0) && ((total_size / nmemb) != size)) ++ { ++ return NULL; ++ } ++ + return kzalloc(nmemb * size, GFP_KERNEL); +} + @@ -5711,31 +6924,9 @@ diff -Naur a/kernel/nvidia-drm-linux.c b/kernel/nvidia-drm-linux.c + * Linux loading support code. + *************************************************************************/ + -+static int __init nv_linux_drm_init(void) -+{ -+ return nv_drm_init(); -+} -+ -+static void __exit nv_linux_drm_exit(void) -+{ -+ nv_drm_exit(); -+} -+ -+module_init(nv_linux_drm_init); -+module_exit(nv_linux_drm_exit); -+ -+#if defined(MODULE_LICENSE) -+ MODULE_LICENSE("MIT"); -+#endif -+#if defined(MODULE_INFO) -+ MODULE_INFO(supported, "external"); -+#endif -+#if defined(MODULE_VERSION) -+ MODULE_VERSION(NV_VERSION_STRING); -+#endif diff -Naur a/kernel/nvidia-drm-os-interface.h b/kernel/nvidia-drm-os-interface.h --- a/kernel/nvidia-drm-os-interface.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-os-interface.h 2022-06-05 13:18:33.956571726 +0200 ++++ b/kernel/nvidia-drm-os-interface.h 2023-03-04 13:26:25.838019986 +0100 @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. @@ -5795,7 +6986,7 @@ diff -Naur a/kernel/nvidia-drm-os-interface.h b/kernel/nvidia-drm-os-interface.h +#endif /* __NVIDIA_DRM_OS_INTERFACE_H__ */ diff -Naur a/kernel/nvidia-drm-priv.h b/kernel/nvidia-drm-priv.h --- a/kernel/nvidia-drm-priv.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvidia-drm-priv.h 2022-06-05 13:18:33.956571726 +0200 ++++ b/kernel/nvidia-drm-priv.h 2023-03-04 13:26:25.839019963 +0100 @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2015, NVIDIA CORPORATION. All rights reserved. @@ -5916,9 +7107,43 @@ diff -Naur a/kernel/nvidia-drm-priv.h b/kernel/nvidia-drm-priv.h +#endif /* defined(NV_DRM_AVAILABLE) */ + +#endif /* __NVIDIA_DRM_PRIV_H__ */ +diff -Naur a/kernel/nvidia-modules-common.mk b/kernel/nvidia-modules-common.mk +--- a/kernel/nvidia-modules-common.mk 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nvidia-modules-common.mk 2023-03-04 13:26:40.805674920 +0100 +@@ -149,10 +149,10 @@ + CONFTEST_HEADERS := $(obj)/conftest.h $(CONFTEST_COMPILE_TEST_HEADERS) \ + $(obj)/conftest/patches.h + +-$(obj)/conftest.h $(CONFTEST_COMPILE_TEST_HEADERS): conftest-compile-test ++# $(obj)/conftest.h $(CONFTEST_COMPILE_TEST_HEADERS): conftest-compile-test + +-conftest-compile-test: $(src)/conftest.sh +- @if ! $(CONFTEST) compile_tests $(COMPILE_TESTS); then exit 1; fi ++# conftest-compile-test: $(src)/conftest.sh ++# @if ! $(CONFTEST) compile_tests $(COMPILE_TESTS); then exit 1; fi + + $(obj)/conftest/patches.h: + @if ! $(CONFTEST) patch_check; then exit 1; fi +@@ -222,6 +222,7 @@ + define BUILD_MODULE_RULE + $(1): build-sanity-checks $(3) + @echo "NVIDIA: calling KBUILD..."; \ ++ touch .nv-kernel.o.cmd; \ + $$(MAKE) "CC=$$(CC)" NV_MODULE_SUFFIX=$$(strip $(2)) $$(KBUILD_PARAMS) modules; \ + echo "NVIDIA: left KBUILD."; \ + if ! [ -f $(1) ]; then \ +@@ -317,7 +318,7 @@ + @$(RM) -f build-in.o nv-linux*.o *.d .*.cmd .*.flags + @$(RM) -f $(MODULE_NAME)*.o $(MODULE_NAME)*.ko* + @$(RM) -f $(MODULE_NAME)*.mod* $(VERSION_HEADER) *~ +- @$(RM) -f conftest*.c conftest.h ++ @$(RM) -f conftest*.c + @$(RM) -rf conftest + @$(RM) -rf Module*.symvers .tmp_versions modules.order + diff -Naur a/kernel/nvkms-api-types.h b/kernel/nvkms-api-types.h --- a/kernel/nvkms-api-types.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvkms-api-types.h 2022-06-05 13:18:33.957571704 +0200 ++++ b/kernel/nvkms-api-types.h 2023-03-04 13:26:25.839019963 +0100 @@ -0,0 +1,306 @@ +/* + * Copyright (c) 2014-2015, NVIDIA CORPORATION. All rights reserved. @@ -6228,7 +7453,7 @@ diff -Naur a/kernel/nvkms-api-types.h b/kernel/nvkms-api-types.h +#endif /* NVKMS_API_TYPES_H */ diff -Naur a/kernel/nvkms-kapi.h b/kernel/nvkms-kapi.h --- a/kernel/nvkms-kapi.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nvkms-kapi.h 2022-06-05 13:18:33.957571704 +0200 ++++ b/kernel/nvkms-kapi.h 2023-03-04 13:26:25.840019940 +0100 @@ -0,0 +1,788 @@ +/* _NVRM_COPYRIGHT_BEGIN_ + * @@ -7018,9 +8243,363 @@ diff -Naur a/kernel/nvkms-kapi.h b/kernel/nvkms-kapi.h +/** @} */ + +#endif /* defined(__NVKMS_KAPI_H__) */ +diff -Naur a/kernel/nv-linux.h b/kernel/nv-linux.h +--- a/kernel/nv-linux.h 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-linux.h 2023-03-04 13:26:40.799675059 +0100 +@@ -119,12 +119,15 @@ + #include <asm/tlbflush.h> /* flush_tlb(), flush_tlb_all() */ + #include <linux/cpu.h> /* CPU hotplug support */ + #endif +-#include <asm/kmap_types.h> /* page table entry lookup */ ++#if defined(NV_ASM_KMAP_TYPES_H_PRESENT) ++ #include <asm/kmap_types.h> /* page table entry lookup */ ++#endif + + #include <linux/pci.h> /* pci_find_class, etc */ + #include <linux/interrupt.h> /* tasklets, interrupt helpers */ + #include <linux/timer.h> +- ++#include <linux/file.h> /* fget(), fput() ++*/ + #include <asm/div64.h> /* do_div() */ + #if defined(NV_ASM_SYSTEM_H_PRESENT) + #include <asm/system.h> /* cli, sli, save_flags */ +@@ -134,7 +137,7 @@ + #include <asm/page.h> /* PAGE_OFFSET */ + #include <asm/pgtable.h> /* pte bit definitions */ + +-#if defined(NVCPU_X86_64) && !defined(HAVE_COMPAT_IOCTL) ++#if defined(NVCPU_X86_64) && !defined(NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL) + #include <linux/syscalls.h> /* sys_ioctl() */ + #include <linux/ioctl32.h> /* register_ioctl32_conversion() */ + #endif +@@ -255,7 +258,8 @@ + * NVIDIA graphics driver has no way of knowing and is unlikely + * to work correctly. + */ +-#if defined(CONFIG_XEN) && !defined(CONFIG_PARAVIRT) ++#if defined(CONFIG_XEN) && !defined(CONFIG_PARAVIRT) && \ ++ !defined(NVCPU_ARM) + #include <asm/maddr.h> + #include <xen/interface/memory.h> + #define NV_XEN_SUPPORT_FULLY_VIRTUALIZED_KERNEL +@@ -308,18 +312,14 @@ + #endif + #endif + +-#if defined(NV_PCI_DMA_MAPPING_ERROR_PRESENT) +-#if (NV_PCI_DMA_MAPPING_ERROR_ARGUMENT_COUNT == 2) +-#define NV_PCI_DMA_MAPPING_ERROR(dev, addr) \ +- pci_dma_mapping_error(dev, addr) +-#elif (NV_PCI_DMA_MAPPING_ERROR_ARGUMENT_COUNT == 1) +-#define NV_PCI_DMA_MAPPING_ERROR(dev, addr) \ +- pci_dma_mapping_error(addr) ++#if (NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT == 2) ++#define NV_DMA_MAPPING_ERROR(dev, addr) \ ++ dma_mapping_error(dev, addr) ++#elif (NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT == 1) ++#define NV_DMA_MAPPING_ERROR(dev, addr) \ ++ dma_mapping_error(addr) + #else +-#error "NV_PCI_DMA_MAPPING_ERROR_ARGUMENT_COUNT value unrecognized!" +-#endif +-#elif defined(NV_VM_INSERT_PAGE_PRESENT) +-#error "NV_PCI_DMA_MAPPING_ERROR() undefined!" ++#error "NV_DMA_MAPPING_ERROR_ARGUMENT_COUNT value unrecognized!" + #endif + + #if defined(NV_LINUX_ACPI_EVENTS_SUPPORTED) +@@ -669,11 +669,19 @@ + # define KM_FREE_RECORD(a,b,c) + #endif + ++#if !defined(NV_VMALLOC_HAS_PGPROT_T_ARG) ++#define NV_VMALLOC(ptr, size) \ ++ { \ ++ (ptr) = __vmalloc(size, GFP_KERNEL); \ ++ VM_ALLOC_RECORD(ptr, size, "vm_vmalloc"); \ ++ } ++#else + #define NV_VMALLOC(ptr, size) \ + { \ + (ptr) = __vmalloc(size, GFP_KERNEL, PAGE_KERNEL); \ + VM_ALLOC_RECORD(ptr, size, "vm_vmalloc"); \ + } ++#endif + + #define NV_VFREE(ptr, size) \ + { \ +@@ -688,11 +696,16 @@ + VM_ALLOC_RECORD(ptr, size, "vm_ioremap"); \ + } + ++#if defined(NV_IOREMAP_NOCACHE_PRESENT) + #define NV_IOREMAP_NOCACHE(ptr, physaddr, size) \ + { \ + (ptr) = ioremap_nocache(physaddr, size); \ + VM_ALLOC_RECORD(ptr, size, "vm_ioremap_nocache"); \ + } ++#else ++#define NV_IOREMAP_NOCACHE(ptr, physaddr, size) \ ++ NV_IOREMAP(ptr, physaddr, size) ++#endif + + #if defined(NV_IOREMAP_CACHE_PRESENT) + #define NV_IOREMAP_CACHE(ptr, physaddr, size) \ +@@ -774,6 +787,17 @@ + #error "NV_KMEM_CACHE_CREATE() undefined (kmem_cache_create() unavailable)!" + #endif + ++#if defined(NV_KMEM_CACHE_CREATE_USERCOPY_PRESENT) ++#define NV_KMEM_CACHE_CREATE_USERCOPY(kmem_cache, name, type) \ ++ { \ ++ kmem_cache = kmem_cache_create_usercopy(name, sizeof(type), \ ++ 0, 0, 0, sizeof(type), NULL); \ ++ } ++#else ++#define NV_KMEM_CACHE_CREATE_USERCOPY(kmem_cache, name, type) \ ++ NV_KMEM_CACHE_CREATE(kmem_cache, name, type) ++#endif ++ + #define NV_KMEM_CACHE_ALLOC(ptr, kmem_cache, type) \ + { \ + (ptr) = kmem_cache_alloc(kmem_cache, GFP_KERNEL); \ +@@ -1971,6 +1995,19 @@ + }) + #endif + ++#if defined(NV_PROC_OPS_PRESENT) ++#define NV_CREATE_PROC_FILE(filename,parent,__name,__data) \ ++ ({ \ ++ struct proc_dir_entry *__entry; \ ++ int mode = (S_IFREG | S_IRUGO); \ ++ const struct proc_ops *fops = &nv_procfs_##__name##_fops; \ ++ if (fops->proc_write != 0) \ ++ mode |= S_IWUSR; \ ++ __entry = NV_CREATE_PROC_ENTRY(filename, mode, parent, fops, \ ++ __data); \ ++ __entry; \ ++ }) ++#else + #define NV_CREATE_PROC_FILE(filename,parent,__name,__data) \ + ({ \ + struct proc_dir_entry *__entry; \ +@@ -1982,6 +2019,7 @@ + __data); \ + __entry; \ + }) ++#endif + + /* + * proc_mkdir_mode exists in Linux 2.6.9, but isn't exported until Linux 3.0. +@@ -2010,9 +2048,11 @@ + }) + + #if defined(NV_PDE_DATA_PRESENT) +-# define NV_PDE_DATA(inode) PDE_DATA(inode) ++#define NV_PDE_DATA(inode) pde_data(inode) ++#elif defined(NV_PDE_DATA_UPPER_CASE_PRESENT) ++#define NV_PDE_DATA(inode) PDE_DATA(inode) + #else +-# define NV_PDE_DATA(inode) PDE(inode)->data ++#define NV_PDE_DATA(inode) PDE(inode)->data + #endif + + #if defined(NV_PROC_REMOVE_PRESENT) +@@ -2023,6 +2063,24 @@ + remove_proc_entry(entry->name, entry->parent); + #endif + ++#if defined(NV_PROC_OPS_PRESENT) ++#define NV_DEFINE_PROCFS_SINGLE_FILE(__name) \ ++ static int nv_procfs_open_##__name( \ ++ struct inode *inode, \ ++ struct file *filep \ ++ ) \ ++ { \ ++ return single_open(filep, nv_procfs_read_##__name, \ ++ NV_PDE_DATA(inode)); \ ++ } \ ++ \ ++ static const struct proc_ops nv_procfs_##__name##_fops = { \ ++ .proc_open = nv_procfs_open_##__name, \ ++ .proc_read = seq_read, \ ++ .proc_lseek = seq_lseek, \ ++ .proc_release = single_release, \ ++ }; ++#else + #define NV_DEFINE_PROCFS_SINGLE_FILE(__name) \ + static int nv_procfs_open_##__name( \ + struct inode *inode, \ +@@ -2040,6 +2098,7 @@ + .llseek = seq_lseek, \ + .release = single_release, \ + }; ++#endif + + #endif /* CONFIG_PROC_FS */ + +@@ -2075,157 +2134,4 @@ + #endif + } + +-/* get_user_pages +- * +- * The 8-argument version of get_user_pages was deprecated by commit +- * (2016 Feb 12: cde70140fed8429acf7a14e2e2cbd3e329036653)for the non-remote case +- * (calling get_user_pages with current and current->mm). +- * +- * Completely moved to the 6 argument version of get_user_pages - +- * 2016 Apr 4: c12d2da56d0e07d230968ee2305aaa86b93a6832 +- * +- * write and force parameters were replaced with gup_flags by - +- * 2016 Oct 12: 768ae309a96103ed02eb1e111e838c87854d8b51 +- * +- * A 7-argument version of get_user_pages was introduced into linux-4.4.y by +- * commit 8e50b8b07f462ab4b91bc1491b1c91bd75e4ad40 which cherry-pciked the +- * replacement of the write and force parameters with gup_flags +- * +- */ +- +-#if defined(NV_GET_USER_PAGES_HAS_TASK_STRUCT) +- #if defined(NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS) +- #define NV_GET_USER_PAGES(start, nr_pages, write, force, pages, vmas) \ +- get_user_pages(current, current->mm, start, nr_pages, write, force, pages, vmas) +- #else +- #include <linux/mm.h> +- #include <linux/sched.h> +- +- static inline long NV_GET_USER_PAGES(unsigned long start, +- unsigned long nr_pages, +- int write, +- int force, +- struct page **pages, +- struct vm_area_struct **vmas) +- { +- unsigned int flags = 0; +- +- if (write) +- flags |= FOLL_WRITE; +- if (force) +- flags |= FOLL_FORCE; +- +- return get_user_pages(current, current->mm, start, nr_pages, flags, +- pages, vmas); +- } +- +- #endif +-#else +- #if defined(NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS) +- #define NV_GET_USER_PAGES get_user_pages +- #else +- #include <linux/mm.h> +- +- static inline long NV_GET_USER_PAGES(unsigned long start, +- unsigned long nr_pages, +- int write, +- int force, +- struct page **pages, +- struct vm_area_struct **vmas) +- { +- unsigned int flags = 0; +- +- if (write) +- flags |= FOLL_WRITE; +- if (force) +- flags |= FOLL_FORCE; +- +- return get_user_pages(start, nr_pages, flags, pages, vmas); +- } +- #endif +-#endif +- +-/* get_user_pages_remote() was added by: +- * 2016 Feb 12: 1e9877902dc7e11d2be038371c6fbf2dfcd469d7 +- * +- * The very next commit (cde70140fed8429acf7a14e2e2cbd3e329036653) +- * deprecated the 8-argument version of get_user_pages for the +- * non-remote case (calling get_user_pages with current and current->mm). +- * +- * The guidelines are: call NV_GET_USER_PAGES_REMOTE if you need the 8-argument +- * version that uses something other than current and current->mm. Use +- * NV_GET_USER_PAGES if you are refering to current and current->mm. +- * +- * Note that get_user_pages_remote() requires the caller to hold a reference on +- * the task_struct (if non-NULL) and the mm_struct. This will always be true +- * when using current and current->mm. If the kernel passes the driver a vma +- * via driver callback, the kernel holds a reference on vma->vm_mm over that +- * callback. +- * +- * get_user_pages_remote() added 'locked' parameter +- * 2016 Dec 14:5b56d49fc31dbb0487e14ead790fc81ca9fb2c99 +- */ +- +-#if defined(NV_GET_USER_PAGES_REMOTE_PRESENT) +- #if defined (NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS) +- #define NV_GET_USER_PAGES_REMOTE get_user_pages_remote +- #else +- static inline long NV_GET_USER_PAGES_REMOTE(struct task_struct *tsk, +- struct mm_struct *mm, +- unsigned long start, +- unsigned long nr_pages, +- int write, +- int force, +- struct page **pages, +- struct vm_area_struct **vmas) +- { +- unsigned int flags = 0; +- +- if (write) +- flags |= FOLL_WRITE; +- if (force) +- flags |= FOLL_FORCE; +- +- #if defined(NV_GET_USER_PAGES_REMOTE_HAS_LOCKED_ARG) +- +- return get_user_pages_remote(tsk, mm, start, nr_pages, flags, +- pages, vmas, NULL); +- +- #else +- +- return get_user_pages_remote(tsk, mm, start, nr_pages, flags, +- pages, vmas); +- +- #endif +- +- } +- #endif +-#else +- #if defined(NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS) +- #define NV_GET_USER_PAGES_REMOTE NV_GET_USER_PAGES +- #else +- #include <linux/mm.h> +- #include <linux/sched.h> +- +- static inline long NV_GET_USER_PAGES_REMOTE(struct task_struct *tsk, +- struct mm_struct *mm, +- unsigned long start, +- unsigned long nr_pages, +- int write, +- int force, +- struct page **pages, +- struct vm_area_struct **vmas) +- { +- unsigned int flags = 0; +- +- if (write) +- flags |= FOLL_WRITE; +- if (force) +- flags |= FOLL_FORCE; +- +- return get_user_pages(tsk, mm, start, nr_pages, flags, pages, vmas); +- } +- #endif +-#endif +- + #endif /* _NV_LINUX_H_ */ diff -Naur a/kernel/nv-mm.h b/kernel/nv-mm.h --- a/kernel/nv-mm.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nv-mm.h 2022-06-05 13:18:33.950571856 +0200 ++++ b/kernel/nv-mm.h 2023-03-04 13:26:25.831020147 +0100 @@ -0,0 +1,285 @@ +/******************************************************************************* + Copyright (c) 2016-2017 NVIDIA Corporation @@ -7307,9 +8886,60 @@ diff -Naur a/kernel/nv-mm.h b/kernel/nv-mm.h +} + +#endif // __NV_MM_H__ +diff -Naur a/kernel/nv-procfs.c b/kernel/nv-procfs.c +--- a/kernel/nv-procfs.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-procfs.c 2023-03-04 13:26:40.800675036 +0100 +@@ -409,6 +409,15 @@ + return ((status < 0) ? status : (int)count); + } + ++#if defined(NV_PROC_OPS_PRESENT) ++static struct proc_ops nv_procfs_registry_fops = { ++ .proc_open = nv_procfs_open_registry, ++ .proc_read = seq_read, ++ .proc_write = nv_procfs_write_file, ++ .proc_lseek = seq_lseek, ++ .proc_release = nv_procfs_close_registry, ++}; ++#else + static struct file_operations nv_procfs_registry_fops = { + .owner = THIS_MODULE, + .open = nv_procfs_open_registry, +@@ -417,6 +426,7 @@ + .llseek = seq_lseek, + .release = nv_procfs_close_registry, + }; ++#endif + + static int + nv_procfs_read_unbind_lock( +@@ -538,6 +548,15 @@ + return rc; + } + ++#if defined(NV_PROC_OPS_PRESENT) ++static struct proc_ops nv_procfs_unbind_lock_fops = { ++ .proc_open = nv_procfs_open_unbind_lock, ++ .proc_read = seq_read, ++ .proc_write = nv_procfs_write_file, ++ .proc_lseek = seq_lseek, ++ .proc_release = nv_procfs_close_unbind_lock, ++}; ++#else + static struct file_operations nv_procfs_unbind_lock_fops = { + .owner = THIS_MODULE, + .open = nv_procfs_open_unbind_lock, +@@ -546,6 +565,7 @@ + .llseek = seq_lseek, + .release = nv_procfs_close_unbind_lock, + }; ++#endif + + static int + nv_procfs_read_text_file( diff -Naur a/kernel/nv_stdarg.h b/kernel/nv_stdarg.h --- a/kernel/nv_stdarg.h 1970-01-01 01:00:00.000000000 +0100 -+++ b/kernel/nv_stdarg.h 2022-06-05 13:18:33.951571834 +0200 ++++ b/kernel/nv_stdarg.h 2023-03-04 13:26:25.832020124 +0100 @@ -0,0 +1,39 @@ +/* + * SPDX-FileCopyrightText: Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved. @@ -7352,7 +8982,7 @@ diff -Naur a/kernel/nv_stdarg.h b/kernel/nv_stdarg.h +#endif // _NV_STDARG_H_ diff -Naur a/kernel/nv-time.h b/kernel/nv-time.h --- a/kernel/nv-time.h 2019-12-11 23:04:24.000000000 +0100 -+++ b/kernel/nv-time.h 2022-06-05 13:18:33.950571856 +0200 ++++ b/kernel/nv-time.h 2023-03-04 13:26:25.831020147 +0100 @@ -23,12 +23,20 @@ #ifndef __NV_TIME_H__ #define __NV_TIME_H__ @@ -7384,3 +9014,396 @@ diff -Naur a/kernel/nv-time.h b/kernel/nv-time.h .tv_sec = now.tv_sec, .tv_usec = now.tv_nsec/1000, }; +diff -Naur a/kernel/nv-vm.c b/kernel/nv-vm.c +--- a/kernel/nv-vm.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-vm.c 2023-03-04 13:26:40.800675036 +0100 +@@ -12,6 +12,9 @@ + #include "os-interface.h" + #include "nv.h" + #include "nv-linux.h" ++#if defined(NV_ASM_SET_MEMORY_H_PRESENT) ++#include <asm/set_memory.h> ++#endif + + static inline void nv_set_contig_memory_uc(nv_pte_t *page_ptr, NvU32 num_pages) + { +@@ -169,12 +172,20 @@ + + static inline int nv_map_sg(struct pci_dev *dev, struct scatterlist *sg) + { ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ++ return dma_map_sg(&dev->dev, sg, 1, DMA_BIDIRECTIONAL); ++#else + return pci_map_sg(dev, sg, 1, PCI_DMA_BIDIRECTIONAL); ++#endif + } + + static inline void nv_unmap_sg(struct pci_dev *dev, struct scatterlist *sg) + { ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ++ dma_unmap_sg(&dev->dev, sg, 1, DMA_BIDIRECTIONAL); ++#else + pci_unmap_sg(dev, sg, 1, PCI_DMA_BIDIRECTIONAL); ++#endif + } + + #define NV_MAP_SG_MAX_RETRIES 16 +diff -Naur a/kernel/os-interface.c b/kernel/os-interface.c +--- a/kernel/os-interface.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/os-interface.c 2023-03-04 13:26:40.806674897 +0100 +@@ -439,7 +439,7 @@ + NvU32 *useconds + ) + { +- struct timeval tm; ++ nv_timeval tm; + + nv_gettimeofday(&tm); + +@@ -474,7 +474,7 @@ + unsigned long usec; + + #ifdef NV_CHECK_DELAY_ACCURACY +- struct timeval tm1, tm2; ++ nv_timeval tm1, tm2; + + nv_gettimeofday(&tm1); + #endif +@@ -514,9 +514,9 @@ + unsigned long MicroSeconds; + unsigned long jiffies; + unsigned long mdelay_safe_msec; +- struct timeval tm_end, tm_aux; ++ nv_timeval tm_end, tm_aux; + #ifdef NV_CHECK_DELAY_ACCURACY +- struct timeval tm_start; ++ nv_timeval tm_start; + #endif + + nv_gettimeofday(&tm_aux); +@@ -549,7 +549,7 @@ + // the requested timeout has expired, loop until less + // than a jiffie of the desired delay remains. + // +- current->state = TASK_INTERRUPTIBLE; ++ set_current_state(TASK_INTERRUPTIBLE); + do + { + schedule_timeout(jiffies); +diff -Naur a/kernel/os-interface.h b/kernel/os-interface.h +--- a/kernel/os-interface.h 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/os-interface.h 2023-03-04 13:26:40.807674874 +0100 +@@ -24,7 +24,7 @@ + * * + \***************************************************************************/ + +-#include <stdarg.h> ++#include "nv_stdarg.h" + + /* + * Define away Microsoft compiler extensions when possible +diff -Naur a/kernel/os-mlock.c b/kernel/os-mlock.c +--- a/kernel/os-mlock.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/os-mlock.c 2023-03-04 13:26:40.807674874 +0100 +@@ -14,6 +14,8 @@ + #include "os-interface.h" + #include "nv-linux.h" + ++#include "nv-mm.h" ++ + RM_STATUS NV_API_CALL os_lock_user_pages( + void *address, + NvU64 page_count, +@@ -44,10 +46,10 @@ + return rmStatus; + } + +- down_read(&mm->mmap_sem); ++ nv_mmap_read_lock(mm); + ret = NV_GET_USER_PAGES((unsigned long)address, + page_count, write, force, user_pages, NULL); +- up_read(&mm->mmap_sem); ++ nv_mmap_read_unlock(mm); + pinned = ret; + + if (ret < 0) +diff -Naur a/kernel/uvm/conftest.sh b/kernel/uvm/conftest.sh +--- a/kernel/uvm/conftest.sh 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/uvm/conftest.sh 2023-03-04 13:26:40.809674828 +0100 +@@ -176,6 +176,7 @@ + FILES="$FILES linux/ktime.h" + FILES="$FILES linux/file.h" + ++ FILES_ARCH="$FILES_ARCH asm/pgtable.h" + FILES_ARCH="$FILES_ARCH asm/set_memory.h" + + translate_and_find_header_files $HEADERS $FILES +@@ -440,6 +441,9 @@ + # Determine if the set_memory_array_uc() function is present. + # + CODE=" ++ #if defined(NV_ASM_PGTABLE_H_PRESENT) ++ #include <asm/pgtable.h> ++ #endif + #if defined(NV_ASM_SET_MEMORY_H_PRESENT) + #include <asm/set_memory.h> + #else +diff -Naur a/kernel/uvm/Makefile b/kernel/uvm/Makefile +--- a/kernel/uvm/Makefile 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/uvm/Makefile 2023-03-04 13:26:40.808674851 +0100 +@@ -207,6 +207,7 @@ + + RM_MODULE_SYMVERS:= $(RM_OUT_DIR)/Module.symvers + UVM_MODULE_SYMVERS:= $(obj)/Module.symvers ++KBUILD_EXTRA_SYMBOLS:= $(UVM_MODULE_SYMVERS) + + module $(MODULE_NAME).ko: $(UVM_MODULE_SYMVERS) debug_diagnostics_printing + +diff -Naur a/kernel/uvm/nvidia_uvm_linux.h b/kernel/uvm/nvidia_uvm_linux.h +--- a/kernel/uvm/nvidia_uvm_linux.h 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/uvm/nvidia_uvm_linux.h 2023-03-04 13:26:40.810674805 +0100 +@@ -141,7 +141,9 @@ + #if !defined(NV_VMWARE) + #include <asm/tlbflush.h> /* flush_tlb(), flush_tlb_all() */ + #endif +-#include <asm/kmap_types.h> /* page table entry lookup */ ++#if defined(NV_ASM_KMAP_TYPES_H_PRESENT) ++ #include <asm/kmap_types.h> /* page table entry lookup */ ++#endif + + #include <linux/interrupt.h> /* tasklets, interrupt helpers */ + #include <linux/timer.h> +@@ -156,7 +158,7 @@ + #include <asm/page.h> /* PAGE_OFFSET */ + #include <asm/pgtable.h> /* pte bit definitions */ + +-#if defined(NVCPU_X86_64) && !defined(HAVE_COMPAT_IOCTL) ++#if defined(NVCPU_X86_64) && !defined(NV_FILE_OPERATIONS_HAS_COMPAT_IOCTL) + #include <linux/syscalls.h> /* sys_ioctl() */ + #include <linux/ioctl32.h> /* register_ioctl32_conversion() */ + #endif +diff -Naur a/kernel/uvm/nvidia_uvm_lite_api.c b/kernel/uvm/nvidia_uvm_lite_api.c +--- a/kernel/uvm/nvidia_uvm_lite_api.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/uvm/nvidia_uvm_lite_api.c 2023-03-04 13:26:40.812674759 +0100 +@@ -30,6 +30,12 @@ + #include "uvm_gpu_ops_tests.h" + #endif + ++#if defined (NV_MM_HAS_MMAP_LOCK) ++#define mmap_sem mmap_lock ++#endif ++ ++#include "nv-mm.h" ++ + // + // nvidia_uvm_lite_api.c + // +@@ -161,13 +167,13 @@ + return RM_ERR_NOT_SUPPORTED; + } + +- down_write(&current->mm->mmap_sem); ++ nv_mmap_write_lock(current->mm); + + vma = find_uvmlite_vma(pParams->requestedBase, pParams->length, filp); + + if (!vma) + { +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + UVM_ERR_PRINT("Failed to find the vma (base: 0x%llx, length: %llu\n", + pParams->requestedBase, pParams->length); + return RM_ERR_UVM_ADDRESS_IN_USE; +@@ -178,7 +184,7 @@ + + if (!pRecord) + { +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + UVM_ERR_PRINT("attempted to commit region without a preceding mmap() " + "call\n"); + return RM_ERR_OBJECT_NOT_FOUND; +@@ -187,7 +193,7 @@ + if ((pRecord->baseAddress != pParams->requestedBase) || + (PAGE_ALIGN(pRecord->length) != PAGE_ALIGN(pParams->length))) + { +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + UVM_ERR_PRINT("attempted to commit region with different VA or length" + " than used by preceding mmap\n"); + return RM_ERR_UVM_ADDRESS_IN_USE; +@@ -206,7 +212,7 @@ + } + + up_write(&pPriv->uvmPrivLock); +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + + return rmStatus; + } +@@ -235,12 +241,12 @@ + pParams->requestedBase, pParams->length, + pParams->newStreamId); + +- down_write(&current->mm->mmap_sem); ++ nv_mmap_write_lock(current->mm); + + vma = find_uvmlite_vma(pParams->requestedBase, pParams->length, filp); + if (vma == NULL) + { +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + return RM_ERR_UVM_ADDRESS_IN_USE; + } + +@@ -250,7 +256,7 @@ + rmStatus = uvmlite_region_set_stream(pRecord, pParams->newStreamId); + + up_write(&pPriv->uvmPrivLock); +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + + return rmStatus; + } +@@ -264,11 +270,11 @@ + + UVM_DBG_PRINT_RL("streamID: 0x%llx\n", pParams->streamId); + +- down_write(&current->mm->mmap_sem); ++ nv_mmap_write_lock(current->mm); + down_write(&pPriv->uvmPrivLock); + rmStatus = uvmlite_set_stream_running(pPriv, pParams->streamId); + up_write(&pPriv->uvmPrivLock); +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + + return rmStatus; + } +@@ -290,12 +296,12 @@ + pParams->streamIdArray[pParams->nStreams - 1]); + } + +- down_write(&current->mm->mmap_sem); ++ nv_mmap_write_lock(current->mm); + down_write(&pPriv->uvmPrivLock); + rmStatus = uvmlite_set_streams_stopped(pPriv, pParams->streamIdArray, + pParams->nStreams); + up_write(&pPriv->uvmPrivLock); +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + return rmStatus; + } + +@@ -311,12 +317,12 @@ + "flags: 0x%x\n", + pParams->requestedBase, pParams->length, pParams->flags); + +- down_write(&current->mm->mmap_sem); ++ nv_mmap_write_lock(current->mm); + + vma = find_uvmlite_vma(pParams->requestedBase, pParams->length, filp); + if (vma == NULL) + { +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + return RM_ERR_UVM_ADDRESS_IN_USE; + } + +@@ -329,7 +335,7 @@ + vma, + pRecord); + up_write(&pPriv->uvmPrivLock); +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + + return rmStatus; + } +@@ -385,7 +391,7 @@ + return rmStatus; + } + +- down_write(&current->mm->mmap_sem); ++ nv_mmap_write_lock(current->mm); + rmStatus = RM_ERR_INVALID_ARGUMENT; + vma = find_counters_vma((unsigned long long) countersBaseAddress, + UVM_MAX_GPUS * UVM_PER_RESOURCE_COUNTERS_SIZE + +@@ -416,7 +422,7 @@ + } + } + +- up_write(&current->mm->mmap_sem); ++ nv_mmap_write_unlock(current->mm); + + // + // We can not reverse uvm_map_page, so inserted pages will stay +diff -Naur a/kernel/uvm/nvidia_uvm_lite.c b/kernel/uvm/nvidia_uvm_lite.c +--- a/kernel/uvm/nvidia_uvm_lite.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/uvm/nvidia_uvm_lite.c 2023-03-04 13:26:40.811674782 +0100 +@@ -131,8 +131,8 @@ + RM_STATUS _preexisting_error_on_channel(UvmGpuMigrationTracking *pMigTracker, + UvmCommitRecord *pRecord); + +-static void _set_timeout_in_usec(struct timeval *src, +- struct timeval *result, ++static void _set_timeout_in_usec(nv_timeval *src, ++ nv_timeval *result, + unsigned long timeoutInUsec) + { + if (!src || !result) +@@ -820,7 +820,13 @@ + } + + #if defined(NV_VM_OPERATIONS_STRUCT_HAS_FAULT) ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0) ++vm_fault_t _fault(struct vm_fault *vmf) ++#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) ++int _fault(struct vm_fault *vmf) ++#else + int _fault(struct vm_area_struct *vma, struct vm_fault *vmf) ++#endif + { + #if defined(NV_VM_FAULT_HAS_ADDRESS) + unsigned long vaddr = vmf->address; +@@ -828,8 +834,15 @@ + unsigned long vaddr = (unsigned long)vmf->virtual_address; + #endif + struct page *page = NULL; ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0) ++ vm_fault_t retval; ++#else + int retval; + ++#endif ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) ++ struct vm_area_struct *vma = vmf->vma; ++#endif + retval = _fault_common(vma, vaddr, &page, vmf->flags); + + vmf->page = page; +@@ -868,7 +881,13 @@ + // it's dealing with anonymous mapping (see handle_pte_fault). + // + #if defined(NV_VM_OPERATIONS_STRUCT_HAS_FAULT) ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 17, 0) ++vm_fault_t _sigbus_fault(struct vm_fault *vmf) ++#elif LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) ++int _sigbus_fault(struct vm_fault *vmf) ++#else + int _sigbus_fault(struct vm_area_struct *vma, struct vm_fault *vmf) ++#endif + { + vmf->page = NULL; + return VM_FAULT_SIGBUS; +@@ -1992,9 +2011,9 @@ + static RM_STATUS _check_ecc_errors(UvmGpuMigrationTracking *pMigTracker, + NvBool *pIsEccErrorSet) + { +- struct timeval eccErrorStartTime = {0}; +- struct timeval eccErrorCurrentTime = {0}; +- struct timeval eccTimeout = {0}; ++ nv_timeval eccErrorStartTime = {0}; ++ nv_timeval eccErrorCurrentTime = {0}; ++ nv_timeval eccTimeout = {0}; + NvBool bEccErrorTimeout = NV_FALSE; + NvBool bEccIncomingError = NV_FALSE; + unsigned rmInterruptSet = 0; diff --git a/kernel-6.3.1.patch b/kernel-6.3.1.patch new file mode 100644 index 0000000..e6f75bc --- /dev/null +++ b/kernel-6.3.1.patch @@ -0,0 +1,108 @@ +diff -Naur a/kernel/nv-mmap.c b/kernel/nv-mmap.c +--- a/kernel/nv-mmap.c 2019-12-11 23:04:24.000000000 +0100 ++++ b/kernel/nv-mmap.c 2023-05-08 18:24:23.402897733 +0200 +@@ -312,7 +312,11 @@ + goto done; + } + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ vm_flags_set(vma, VM_IO); ++#else + vma->vm_flags |= VM_IO; ++#endif + } + else + { +@@ -363,8 +367,13 @@ + + NV_PRINT_AT(NV_DBG_MEMINFO, at); + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ vm_flags_set(vma, VM_IO | VM_LOCKED | VM_RESERVED); ++ vm_flags_set(vma, VM_DONTEXPAND | VM_DONTDUMP); ++#else + vma->vm_flags |= (VM_IO | VM_LOCKED | VM_RESERVED); + vma->vm_flags |= (VM_DONTEXPAND | VM_DONTDUMP); ++#endif + } + + if (status == 0) +@@ -374,8 +383,13 @@ + if ((prot & NV_PROTECT_WRITEABLE) == 0) + { + vma->vm_page_prot = NV_PGPROT_READ_ONLY(vma->vm_page_prot); ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ vm_flags_clear(vma, VM_WRITE); ++ vm_flags_clear(vma, VM_MAYWRITE); ++#else + vma->vm_flags &= ~VM_WRITE; + vma->vm_flags &= ~VM_MAYWRITE; ++#endif + } + + vma->vm_ops = &nv_vm_ops; +diff -Naur a/kernel/uvm/nvidia_uvm_lite.c b/kernel/uvm/nvidia_uvm_lite.c +--- a/kernel/uvm/nvidia_uvm_lite.c 2023-03-04 13:09:34.850313572 +0100 ++++ b/kernel/uvm/nvidia_uvm_lite.c 2023-05-08 18:26:25.391148890 +0200 +@@ -1524,10 +1524,17 @@ + + vma->vm_ops = &uvmlite_vma_ops; + ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ // Prohibit copying the vma on fork(). ++ vm_flags_set(vma, VM_DONTCOPY); ++ // Prohibt mremap() that would expand the vma. ++ vm_flags_set(vma, VM_DONTEXPAND); ++#else + // Prohibit copying the vma on fork(). + vma->vm_flags |= VM_DONTCOPY; + // Prohibt mremap() that would expand the vma. + vma->vm_flags |= VM_DONTEXPAND; ++#endif + + // Other cases of vma modification are detected in _mmap_open(). + +@@ -1546,9 +1553,15 @@ + return -EINVAL; + + vma->vm_ops = &counters_vma_ops; ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ vm_flags_clear(vma, VM_MAYWRITE); ++ // prevent vm_insert_page from modifying the vma's flags: ++ vm_flags_set(vma, VM_MIXEDMAP); ++#else + vma->vm_flags &= ~VM_MAYWRITE; + // prevent vm_insert_page from modifying the vma's flags: + vma->vm_flags |= VM_MIXEDMAP; ++#endif + ret = 0; + } + UVM_DBG_PRINT_RL("vma 0x%p [0x%p, 0x%p) ret %d pgoff" +@@ -2527,8 +2540,13 @@ + // Subsequent access from userspace after the pages are unmapped will cause + // a SIGSEGV. + // ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ vm_flags_clear(vma, VM_READ|VM_MAYREAD); ++ vm_flags_clear(vma, VM_WRITE|VM_MAYWRITE); ++#else + vma->vm_flags &= ~(VM_READ|VM_MAYREAD); + vma->vm_flags &= ~(VM_WRITE|VM_MAYWRITE); ++#endif + } + + // +@@ -2536,8 +2554,13 @@ + // + static void _set_vma_accessible(struct vm_area_struct * vma) + { ++#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0) ++ vm_flags_set(vma, VM_READ|VM_MAYREAD); ++ vm_flags_set(vma, VM_WRITE|VM_MAYWRITE); ++#else + vma->vm_flags |= (VM_READ|VM_MAYREAD); + vma->vm_flags |= (VM_WRITE|VM_MAYWRITE); ++#endif + } + + // diff --git a/kernel-6.5.2.patch b/kernel-6.5.2.patch new file mode 100644 index 0000000..16a854b --- /dev/null +++ b/kernel-6.5.2.patch @@ -0,0 +1,77 @@ +diff -Naur a/kernel/conftest.sh b/kernel/conftest.sh +--- a/kernel/conftest.sh 2023-03-04 13:09:34.870313112 +0100 ++++ b/kernel/conftest.sh 2023-09-11 17:10:38.066651279 +0200 +@@ -3213,6 +3213,30 @@ + return + fi + ++ # Conftest #4: check if vma arg was dropped ++ # Return if available. ++ # Fall through to default case if absent. ++ ++ echo "$CONFTEST_PREAMBLE ++ #include <linux/mm.h> ++ long get_user_pages(unsigned long start, ++ unsigned long nr_pages, ++ unsigned int gup_flags, ++ struct page **pages) { ++ return 0; ++ }" > conftest$$.c ++ ++ $CC $CFLAGS -c conftest$$.c > /dev/null 2>&1 ++ rm -f conftest$$.c ++ ++ if [ -f conftest$$.o ]; then ++ echo "#define NV_GET_USER_PAGES_DROPPED_VMA" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" ++ echo "#undef NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" ++ rm -f conftest$$.o ++ return ++ fi ++ + echo "#define NV_GET_USER_PAGES_HAS_WRITE_AND_FORCE_ARGS" | append_conftest "functions" + echo "#define NV_GET_USER_PAGES_HAS_TASK_STRUCT" | append_conftest "functions" + +@@ -3220,6 +3244,8 @@ + ;; + + get_user_pages_remote) ++ echo "#define NV_GET_USER_PAGES_REMOTE_UNUSED" | append_conftest "functions" ++ return + # + # Determine if the function get_user_pages_remote() is + # present and has write/force/locked/tsk parameters. +diff -Naur a/kernel/nv-mm.h b/kernel/nv-mm.h +--- a/kernel/nv-mm.h 2022-10-12 11:30:26.000000000 +0200 ++++ b/kernel/nv-mm.h 2023-09-11 17:17:20.528698065 +0200 +@@ -93,7 +93,11 @@ + if (force) + flags |= FOLL_FORCE; + +- return get_user_pages(start, nr_pages, flags, pages, vmas); ++ #if defined(NV_GET_USER_PAGES_DROPPED_VMA) ++ return get_user_pages(start, nr_pages, flags, pages); ++ #else ++ return get_user_pages(start, nr_pages, flags, pages, vmas); ++ #endif + } + #endif + #endif +@@ -129,7 +133,8 @@ + * all gup code") in v5.9-rc1 (2020-08-11). + * + */ +- ++#if defined(NV_GET_USER_PAGES_REMOTE_UNUSED) ++#else + #if defined(NV_GET_USER_PAGES_REMOTE_PRESENT) + #if defined(NV_GET_USER_PAGES_REMOTE_HAS_WRITE_AND_FORCE_ARGS) + #define NV_GET_USER_PAGES_REMOTE get_user_pages_remote +@@ -195,6 +200,7 @@ + } + #endif + #endif ++#endif + + + /* diff --git a/nvidia-340xx-kmod.spec b/nvidia-340xx-kmod.spec index 0e3823e..b92bae6 100644 --- a/nvidia-340xx-kmod.spec +++ b/nvidia-340xx-kmod.spec @@ -12,16 +12,17 @@ Name: nvidia-340xx-kmod Epoch: 1 Version: 340.108 # Taken over by kmodtool -Release: 26%{?dist} +Release: 27%{?dist} Summary: NVIDIA display driver kernel module Group: System Environment/Kernel License: Redistributable, no modification permitted URL: http://www.nvidia.com/ Source11: nvidia-kmodtool-excludekernel-filterfile -Patch0: import-files-from-390.151.patch +Patch0: import-files-from-390.157.patch Patch1: fix-build-issues.patch -Patch2: 0011-kernel-6.0.patch +Patch2: kernel-6.3.1.patch +Patch3: kernel-6.5.2.patch BuildRequires: elfutils-libelf-devel BuildRequires: gcc @@ -48,9 +49,10 @@ kmodtool --target %{_target_cpu} --repo rpmfusion --kmodname %{name} --filterf %setup -T -c tar --use-compress-program xz -xf %{_datadir}/%{name}-%{version}/%{name}-%{version}-%{_target_cpu}.tar.xz # patch loop -%patch0 -p1 -%patch1 -p1 -%patch2 -p1 +%patch 0 -p1 +%patch 1 -p1 +%patch 2 -p1 +%patch 3 -p1 for kernel_version in %{?kernel_versions} ; do cp -a kernel _kmod_build_${kernel_version%%___*} @@ -79,6 +81,9 @@ done %{?akmod_install} %changelog +* Mon Sep 11 2023 Łukasz Wojniłowicz <lukasz.wojnilowicz(a)gmail.com&gt; - 1:340.108-27 +- Fix build on kernel-6.5.2 + * Thu Aug 03 2023 RPM Fusion Release Engineering <sergiomb(a)rpmfusion.org&gt; - 1:340.108-26 - Rebuilt for https://fedoraproject.org/wiki/Fedora_39_Mass_Rebuild