ASoC: tegra: avoid enabling aud_mclk during init

Enabling the aud_mclk clock during initialization of drivers
was done for T30 chip due to some external dependencies, now
it is not required for latest version of chips and also due
to this aud_mclk is kept always ON. Add check to avoid enabling
aud_mclk clock other than T30

Bug 4373898

Change-Id: If341b1b73051c5572c5551bf6d4659fab7a116d2
Signed-off-by: Mohan Kumar <mkumard@nvidia.com>
Reviewed-on: https://git-master.nvidia.com/r/c/linux-nv-oot/+/3015891
(cherry picked from commit 7ffd0c9cfa)
Reviewed-on: https://git-master.nvidia.com/r/c/linux-nv-oot/+/3019203
Reviewed-by: Amulya Yarlagadda <ayarlagadda@nvidia.com>
GVS: Gerrit_Virtual_Submit <buildbot_gerritrpt@nvidia.com>

Documentation/devicetree/bindings/nvpps/nvpps.txt

@@ -5,24 +5,19 @@ correlation feature.
 
 Required properties:
 
-- compatible: This should be nvidia,tegra194-nvpps for Xavier and nvidia,tegra234-nvpps for Orin.
+- compatibles: should be "nvpps,tegra194-nvpps"
 
 Optional properties:
-- primary-emac: specifies ethernet emac device DT. This is the primary ethernet MAC device utilized
-		to calculate PTP time. For example, if MGBE0 is used to calculate the PTP time,
-		then phandle of the device tree node corresponding to MGBE0 needs to be passed.
-
-                For Example for Orin:
-                        mgbe0: ethernet@6800000
-                        eqos: ethernet@2310000
-
-                For Example for Xavier:
-                        eqos: ethernet@2490000
-
-- sec-emac: specifies secondary ethernet MAC device DT node to be used to calculate PTP time.
+- gpios: GPIO number and active level for the PPS input signal
 - memmap_phc_regs: boolean flag to indicate MAC PHC regs to be memory mapped
 				   for getting PTP time. If not defined ptp notifer method will
 				   be used with selected interface
+- interface: NW interface name to be used for MAC PHC regs. This field can be
+			 set to 'eqos_0', 'mgbe0_0', 'mgbe1_0', 'mgbe2_0' or 'mgbe3_0' for Orin.
+			 For Xavier, it shoud be set to 'eqos_0'. If undef, default to 'eqos_0'
+- sec_interface: NW interface name to be used to calculate PTP Time offset.
+				 set to 'eqos_0', 'mgbe0_0', 'mgbe1_0', 'mgbe2_0' or 'mgbe3_0' for Orin.
+				 For Xavier, Leave this undefined. For Orin, If undef default to 'eqos_0'
 - ptp_tsc_k_int: Specifies the integer part of the factor used to calculate the delta to
 				 apply to NUM when the fast convergence algorithm is enabled when syncing
 				 or locking TSC time with PTP time domain.
@@ -36,78 +31,42 @@ Optional properties:
 				 If unspecified, NvPPS driver uses 0x26C(corresponding to 20us) by default
 - ptp_tsc_sync_dis: boolean flag to indicate if nvpps should disable PTP TSC sync logic.
 					The default behaviour is to keep PTP TSC sync logic enabled.
-- reg: specifies start address and registers count details of TSC module. It is only applicable for Orin.
-- nvpps-gpios: specifies GPIO number for PPS input signal.
-- timestamps: specifies timestamp for the GPIO provided by HTE.
-- timestamp-names: specifies name for GPIO timestamp.
 
-Example: Timer mode on Orin.
-
-mgbe0: ethernet@6800000{
-};
+Example:
 
 nvpps {
+	compatible = "nvidia,tegrat194-nvpps";
 	status = "okay";
-	compatible = "nvidia,tegra234-nvpps";
-	primary-emac = <&mgbe0>;
-	sec-emac = <&mgbe0>;
-	reg = <0x0 0xc6a0000 0x0 0x1000>;
+	gpios = <&tegra_aon_gpio TEGRA194_AON_GPIO(BB, 2) GPIO_ACTIVE_HIGH>;
 };
 
-Example: Timer mode on Xavier
-
-eqos: ethernet@2490000{
-};
+Example:
 
 nvpps {
-	status = "okay";
 	compatible = "nvidia,tegra194-nvpps";
-	primary-emac = <&eqos>;
-	sec-emac = <&eqos>;
-};
-
-Example: MAC PHC regs to be memory mapped on Orin
-
-mgbe0: ethernet@6800000{
-};
-
-nvpps {
 	status = "okay";
-	compatible = "nvidia,tegra234-nvpps";
-	primary-emac = <&mgbe0>
-	sec-emac = <&mgbe0>;
+	gpios = <&tegra_aon_gpio TEGRA234_AON_GPIO(EE, 6) GPIO_ACTIVE_HIGH>;
 	memmap_phc_regs;
-	reg = <0x0 0xc6a0000 0x0 0x1000>;
+	interface = "mgbe2_0";
 };
 
-
-Example: GPIO mode on Orin
-
-mgbe0: ethernet@6800000{
-};
+Example:
 
 nvpps {
+	compatible = "nvidia,tegra194-nvpps";
 	status = "okay";
-	compatible = "nvidia,tegra234-nvpps";
-	reg = <0x0 0xc6a0000 0x0 0x1000>;
-	nvpps-gpios = <&gpio_aon TEGRA234_AON_GPIO(BB, 0) GPIO_ACTIVE_HIGH>;
-	timestamps = <&hte_aon TEGRA234_AON_GPIO(BB, 0)>;
-	timestamp-names = "nvpps_gpio";
-};
-
-
-Example: Timer mode on Orin with additional properties.
-
-mgbe0: ethernet@6800000{
-};
-
-nvpps {
-	status = "okay";
-	compatible = "nvidia,tegra234-nvpps";
-	primary-emac = <&mgbe0>;
-	sec-emac = <&mgbe0>;
-	reg = <0x0 0xc6a0000 0x0 0x1000>;
+	gpios = <&tegra_aon_gpio TEGRA234_AON_GPIO(EE, 6) GPIO_ACTIVE_HIGH>;
+	interface = "mgbe2_0";
+	sec_interface = "eqos_0";
 	ptp_tsc_k_int = /bits/ 8 <0x70>;
 	ptp_tsc_lock_threshold = /bits/ 16 <0x26C>;
 	ptp_tsc_sync_dis;
 };
+
+Example: GPIO as optional
+
+nvpps {
+	compatible = "nvidia,tegra194-nvpps";
+	status = "okay";
+	interface = "mgbe2_0";
+};

Makefile

@@ -1,11 +1,67 @@
 # SPDX-License-Identifier: GPL-2.0
-# Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
 
 LINUXINCLUDE += -I$(srctree.nvconftest)
 LINUXINCLUDE += -I$(srctree.nvidia-oot)/include
 
 subdir-ccflags-y += -Werror
-subdir-ccflags-y += -Wmissing-prototypes
+
+LINUX_VERSION := $(shell expr $(VERSION) \* 256 + $(PATCHLEVEL))
+LINUX_VERSION_6_2 := $(shell expr 6 \* 256 + 2)
+LINUX_VERSION_6_3 := $(shell expr 6 \* 256 + 3)
+LINUX_VERSION_6_6 := $(shell expr 6 \* 256 + 6)
+
+# The Tegra IVC driver was updated to support iosys-map in Linux v6.2.
+# For Linux v6.2 kernels, don't build any drivers that requires this.
+ifeq ($(shell test $(LINUX_VERSION) -ge $(LINUX_VERSION_6_2); echo $$?),0)
+export CONFIG_TEGRA_IVC_LEGACY_DISABLE=y
+endif
+
+ifeq ($(CONFIG_TEGRA_IVC_LEGACY_DISABLE),y)
+subdir-ccflags-y += -DCONFIG_TEGRA_IVC_LEGACY_DISABLE
+endif
+
+# Legacy GPIO support is removed in Linux v6.3
+ifeq ($(shell test $(LINUX_VERSION) -ge $(LINUX_VERSION_6_3); echo $$?),0)
+export CONFIG_TEGRA_GPIO_LEGACY_DISABLE=y
+endif
+
+# Changes done in Linux 6.6 onwards
+ifeq ($(shell test $(LINUX_VERSION) -ge $(LINUX_VERSION_6_6); echo $$?),0)
+# Move probe to DAI Ops.
+export CONFIG_SND_SOC_MOVE_DAI_PROBE_TO_OPS=y
+subdir-ccflags-y += -DNV_SND_SOC_DAI_OPS_STRUCT_HAS_PROBE_ARG
+
+# probe_new is removed from i2c driver structure
+subdir-ccflags-y += -DNV_I2C_LEGACY_PROBE_NEW_REMOVED
+
+# API changes to replace u8 with unsigned char
+subdir-ccflags-y += -DNV_TTY_SERIAL_TYPE_U8_CHANGE
+
+# v4l2_async_subdev is renamed to v4l2_async_connection.
+subdir-ccflags-y += -DNV_V4L2_ASYNC_SUBDEV_RENAME
+
+# Rename V4L2_ASYNC_MATCH_FWNODE to V4L2_ASYNC_MATCH_TYPE_FWNODE
+subdir-ccflags-y += -DNV_V4L2_ASYNC_MATCH_FWNODE_RENAME
+
+# Rename async_nf_init and v4l2_async_subdev_nf_register
+subdir-ccflags-y += -DNV_V4L2_ASYNC_NF_SUBDEVICE_INIT_RENAME
+
+# Deprecate PCIED Error reporting pci_enable_pcie_error_reporting
+subdir-ccflags-y += -DNV_DROP_PCIE_ERROR_REPORTING
+
+# Split types and declaration of net/page_pool.h
+subdir-ccflags-y += -DNV_SPLIT_PAGE_POOL_HEADER
+
+# Unexport helpers for fd/handle conversion
+subdir-ccflags-y += -DNV_UNEXPORT_FD_HANDLE_CONVERSION
+
+# FB Deferred IO helpers name alignment
+subdir-ccflags-y += -DNV_FB_DEFERRED_IO_OPS_RENAME
+
+# Crypto driver has major change in it ops, skip it
+export CONFIG_SKIP_CRYPTO=y
+endif
 
 ifeq ($(CONFIG_TEGRA_VIRTUALIZATION),y)
 subdir-ccflags-y += -DCONFIG_TEGRA_VIRTUALIZATION

arch/arm64/boot/dts/Makefile

@@ -0,0 +1,41 @@
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2022, NVIDIA CORPORATION.  All rights reserved.
+
+objtree = $(srctree)
+
+# Redefine the fixdep command
+cmd_and_fixdep =                                                             \
+	$(cmd);                                                              \
+	$(objtree)/scripts/basic/fixdep $(depfile) $@ '$(make-cmd)' > $(dot-target).cmd;\
+	rm -f $(depfile)
+
+include $(oottree)/scripts/Makefile.lib
+
+oot-dtstree = $(oottree)/arch/arm64/boot/dts/nvidia
+
+DTB_LIST := $(dtb-y)
+DTBO_LIST := $(dtbo-y)
+dtb-y :=
+dts_makefile=$(foreach d,$(wildcard $1*), $(call dts_makefile,$(d)/,$(2)) $(if $(findstring Makefile,$(d)),$(d)))
+dts_mfiles = $(call dts_makefile, $(oot-dtstree), Makefile)
+
+ifneq ($(dts_mfiles),)
+dts-include :=
+include $(dts_mfiles)
+dtb-y := $(addprefix nvidia/,$(dtb-y))
+dtbo-y := $(addprefix nvidia/,$(dtbo-y))
+endif
+
+DTC_INCLUDE := $(oottree)/include
+
+DTB_LIST += $(dtb-y)
+DTBO_LIST += $(dtbo-y)
+DTB_OBJS := $(addprefix $(obj)/,$(DTB_LIST))
+DTBO_OBJS := $(addprefix $(obj)/,$(DTBO_LIST))
+
+dtbs: $(DTB_OBJS) $(DTBO_OBJS) FORCE
+
+dtbsclean:
+	find $(oot-dtstree) -name *.dtb | xargs rm -rf
+	find $(oot-dtstree) -name *.dtbo | xargs rm -rf
+	find $(oot-dtstree) -name *.tmp | xargs rm -rf

arch/arm64/boot/dts/nvidia/Makefile

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+
+DTC_FLAGS += -@
+
+# DT overlays
+dtbo-y += tegra194-carveouts.dtbo
+dtbo-y += tegra194-jetson.dtbo
+dtbo-y += tegra194-p3509-0000+p3668-0001-overlay.dtbo

arch/arm64/boot/dts/nvidia/tegra194-carveouts.dts

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/dts-v1/;
+/plugin/;
+
+/ {
+	fragment@0 {
+		target-path = "/";
+		__overlay__ {
+
+			reserved-memory {
+				#address-cells = <2>;
+				#size-cells = <2>;
+				ranges;
+
+				vpr: vpr-carveout {
+					compatible = "nvidia,vpr-carveout";
+					status = "okay";
+				};
+			};
+
+			tegra-carveouts {
+				compatible = "nvidia,carveouts-t19x";
+				memory-region = <&vpr>;
+				status = "okay";
+			};
+		};
+	};
+};

arch/arm64/boot/dts/nvidia/tegra194-jetson.dts

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES.
+ *
+ * SPDX-License-Identifier: GPL-2.0
+ */
+
+/dts-v1/;
+/plugin/;
+
+#include <dt-bindings/clock/tegra194-clock.h>
+#include <dt-bindings/interrupt-controller/arm-gic.h>
+#include <dt-bindings/interrupt-controller/irq.h>
+#include <dt-bindings/memory/tegra194-mc.h>
+#include <dt-bindings/power/tegra194-powergate.h>
+#include <dt-bindings/reset/tegra194-reset.h>
+
+/ {
+	overlay-name = "Tegra194 Jetson Overlay";
+	compatible = "nvidia,tegra194";
+
+	fragment@0 {
+		target-path = "/bus@0/host1x@13e00000";
+		__overlay__ {
+			#address-cells = <2>;
+			#size-cells = <2>;
+
+			interrupt-parent = <&gic>;
+
+			ranges = <0x0 0x14800000 0x0 0x14800000 0x0 0x02800000>,
+				 <0x0 0x24f00000 0x0 0x24f00000 0x0 0x00100000>;
+
+			nvdla0@15880000 {
+				compatible = "nvidia,tegra194-nvdla";
+				reg = <0x0 0x15880000 0x0 0x00040000>;
+				interrupts = <GIC_SPI 236 IRQ_TYPE_LEVEL_HIGH>;
+				clocks = <&bpmp TEGRA194_CLK_DLA0_CORE>,
+					 <&bpmp TEGRA194_CLK_DLA0_FALCON>;
+				clock-names = "nvdla", "nvdla_flcn";
+				resets = <&bpmp TEGRA194_RESET_DLA0>;
+				reset-names = "nvdla";
+
+				power-domains = <&bpmp TEGRA194_POWER_DOMAIN_DLAA>;
+				interconnects = <&mc TEGRA194_MEMORY_CLIENT_DLA0RDA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_DLA0FALRDB &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_DLA0WRA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_DLA0FALWRB &emc>;
+				interconnect-names = "dma-mem", "read-1", "write", "write-1";
+				iommus = <&smmu TEGRA194_SID_NVDLA0>;
+				dma-coherent;
+			};
+
+			nvdla1@158c0000 {
+				compatible = "nvidia,tegra194-nvdla";
+				reg = <0x0 0x158c0000 0x0 0x00040000>;
+				interrupts = <GIC_SPI 237 IRQ_TYPE_LEVEL_HIGH>;
+				clocks = <&bpmp TEGRA194_CLK_DLA1_CORE>,
+					 <&bpmp TEGRA194_CLK_DLA1_FALCON>;
+				clock-names = "nvdla", "nvdla_flcn";
+				resets = <&bpmp TEGRA194_RESET_DLA1>;
+				reset-names = "nvdla";
+
+				power-domains = <&bpmp TEGRA194_POWER_DOMAIN_DLAB>;
+				interconnects = <&mc TEGRA194_MEMORY_CLIENT_DLA1RDA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_DLA1FALRDB &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_DLA1WRA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_DLA1FALWRB &emc>;
+				interconnect-names = "dma-mem", "read-1", "write", "write-1";
+				iommus = <&smmu TEGRA194_SID_NVDLA1>;
+				dma-coherent;
+			};
+
+			pva0@16000000 {
+				compatible = "nvidia,tegra194-pva";
+				power-domains = <&bpmp TEGRA194_POWER_DOMAIN_PVAA>;
+				reg = <0x0 0x16000000 0x0 0x00800000>,
+				      <0x0 0x24f00000 0x0 0x00080000>;
+				interrupts = <GIC_SPI 234 IRQ_TYPE_LEVEL_HIGH>;
+
+				resets = <&bpmp TEGRA194_RESET_PVA0_ALL>;
+				reset-names = "nvpva";
+
+				clocks = <&bpmp TEGRA194_CLK_NAFLL_PVA_VPS>,
+					 <&bpmp TEGRA194_CLK_NAFLL_PVA_CORE>,
+					 <&bpmp TEGRA194_CLK_PVA0_AXI>,
+					 <&bpmp TEGRA194_CLK_PVA0_VPS0>,
+					 <&bpmp TEGRA194_CLK_PVA0_VPS1>;
+				clock-names = "nafll_pva_vps", "nafll_pva_core", "axi", "vps0", "vps1";
+
+                                interconnects = <&mc TEGRA194_MEMORY_CLIENT_PVA0RDA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA0RDB &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA0RDC &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA0WRA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA0WRB &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA0WRC &emc>;
+				interconnect-names = "dma-mem", "read-b", "read-c", "write-a", "write-b", "write-c";
+
+
+				iommus = <&smmu TEGRA194_SID_PVA0>;
+				dma-coherent;
+			};
+
+			pva1@16800000 {
+				compatible = "nvidia,tegra194-pva";
+				power-domains = <&bpmp TEGRA194_POWER_DOMAIN_PVAB>;
+				reg = <0x0 0x16800000 0x0 0x00800000>,
+				      <0x0 0x24f80000 0x0 0x00080000>;
+				interrupts = <GIC_SPI 235 IRQ_TYPE_LEVEL_HIGH>;
+
+				resets = <&bpmp TEGRA194_RESET_PVA1_ALL>;
+				reset-names = "nvpva";
+
+				clocks = <&bpmp TEGRA194_CLK_PVA1_AXI>,
+					 <&bpmp TEGRA194_CLK_PVA1_VPS0>,
+					 <&bpmp TEGRA194_CLK_PVA1_VPS1>;
+				clock-names = "axi", "vps0", "vps1";
+
+                                interconnects = <&mc TEGRA194_MEMORY_CLIENT_PVA1RDA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA1RDB &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA1RDC &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA1WRA &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA1WRB &emc>,
+						<&mc TEGRA194_MEMORY_CLIENT_PVA1WRC &emc>;
+				interconnect-names = "dma-mem", "read-b", "read-c", "write-a", "write-b", "write-c";
+
+				iommus = <&smmu TEGRA194_SID_PVA1>;
+				dma-coherent;
+			};
+		};
+	};
+
+	fragment@1 {
+		target-path = "/";
+		__overlay__ {
+			#address-cells = <2>;
+			#size-cells = <2>;
+
+			cvnas@14000000 {
+				compatible = "nvidia,tegra194-cvnas";
+				reg = <0x0 0x14000000 0x0 0x20000>, /* CV0_REG0_BASE */
+				      <0x0 0x14020000 0x0 0x10000>, /* CV0_SRAM_BASE */
+				      <0x0 0x0b240000 0x0 0x10000>; /* HSM_BASE */
+				interrupt-parent = <&gic>;
+				interrupts = <GIC_SPI 238 IRQ_TYPE_LEVEL_HIGH>,
+					     <GIC_SPI 239 IRQ_TYPE_LEVEL_HIGH>;
+				clocks = <&bpmp TEGRA194_CLK_CVNAS>;
+				assigned-clocks = <&bpmp TEGRA194_CLK_CVNAS>;
+				assigned-clock-rates = <1356800000>;
+				resets = <&bpmp TEGRA194_RESET_CVNAS>,
+					 <&bpmp TEGRA194_RESET_CVNAS_FCM>;
+				reset-names = "rst", "rst_fcm";
+				power-domains = <&bpmp TEGRA194_POWER_DOMAIN_CV>;
+				cvsramslice = <4 0x1000>;
+				cvsram-reg = <0x0 0x50000000 0x0 0x400000>;
+			};
+		};
+	};
+};

arch/arm64/boot/dts/nvidia/tegra194-p3509-0000+p3668-0001-overlay.dts

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0
+
+/dts-v1/;
+/plugin/;
+
+/ {
+        overlay-name = "Add p3509-0000+p3668-0001 Overlay Support";
+        compatible = "nvidia,tegra194";
+};

device-tree/platform/generic-dts/Makefile

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: GPL-2.0-only
 
-objtree ?= $(srctree)
+objtree = $(srctree)
 
 # Redefine the fixdep command
 cmd_and_fixdep =                                                             \

dkms.conf

@@ -5,102 +5,102 @@ MAKE[0]="make modules"
 
 BUILT_MODULE_NAME[0]="softdog-platform"
 BUILT_MODULE_LOCATION[0]="drivers/watchdog"
-DEST_MODULE_LOCATION[0]="/updates"
+DEST_MODULE_LOCATION[0]="/extra"
 
 BUILT_MODULE_NAME[1]="watchdog-tegra-t18x"
 BUILT_MODULE_LOCATION[1]="drivers/watchdog"
-DEST_MODULE_LOCATION[1]="/updates"
+DEST_MODULE_LOCATION[1]="/extra"
 
 BUILT_MODULE_NAME[2]="pex9749-thermal"
 BUILT_MODULE_LOCATION[2]="drivers/thermal"
-DEST_MODULE_LOCATION[2]="/updates"
+DEST_MODULE_LOCATION[2]="/extra"
 
 BUILT_MODULE_NAME[3]="spi-aurix-tegra"
 BUILT_MODULE_LOCATION[3]="drivers/spi"
-DEST_MODULE_LOCATION[3]="/updates"
+DEST_MODULE_LOCATION[3]="/extra"
 
 BUILT_MODULE_NAME[4]="tegra186-gpc-dma"
 BUILT_MODULE_LOCATION[4]="drivers/dma"
-DEST_MODULE_LOCATION[4]="/updates"
+DEST_MODULE_LOCATION[4]="/extra"
 
 BUILT_MODULE_NAME[5]="pwm-tegra-tachometer"
 BUILT_MODULE_LOCATION[5]="drivers/pwm"
-DEST_MODULE_LOCATION[5]="/updates"
+DEST_MODULE_LOCATION[5]="/extra"
 
 BUILT_MODULE_NAME[6]="pinctrl-tegra234"
 BUILT_MODULE_LOCATION[6]="drivers/pinctrl/tegra"
-DEST_MODULE_LOCATION[6]="/updates"
+DEST_MODULE_LOCATION[6]="/extra"
 
 BUILT_MODULE_NAME[7]="tegra-cactmon"
 BUILT_MODULE_LOCATION[7]="drivers/platform/tegra"
-DEST_MODULE_LOCATION[7]="/updates"
+DEST_MODULE_LOCATION[7]="/extra"
 
 BUILT_MODULE_NAME[8]="pinctrl-tegra234-dpaux"
 BUILT_MODULE_LOCATION[8]="drivers/pinctrl"
-DEST_MODULE_LOCATION[8]="/updates"
+DEST_MODULE_LOCATION[8]="/extra"
 
 BUILT_MODULE_NAME[9]="tegra-fsicom"
 BUILT_MODULE_LOCATION[9]="drivers/platform/tegra"
-DEST_MODULE_LOCATION[9]="/updates"
+DEST_MODULE_LOCATION[9]="/extra"
 
 BUILT_MODULE_NAME[10]="tegra-bootloader-debug"
 BUILT_MODULE_LOCATION[10]="drivers/platform/tegra"
-DEST_MODULE_LOCATION[10]="/updates"
+DEST_MODULE_LOCATION[10]="/extra"
 
 BUILT_MODULE_NAME[11]="host1x-fence"
 BUILT_MODULE_LOCATION[11]="drivers/gpu/host1x-fence"
-DEST_MODULE_LOCATION[11]="/updates"
+DEST_MODULE_LOCATION[11]="/extra"
 
 BUILT_MODULE_NAME[12]="tegra_vnet"
 BUILT_MODULE_LOCATION[12]="drivers/net/ethernet/nvidia/pcie"
-DEST_MODULE_LOCATION[12]="/updates"
+DEST_MODULE_LOCATION[12]="/extra"
 
 BUILT_MODULE_NAME[13]="arm64-ras"
 BUILT_MODULE_LOCATION[13]="drivers/ras"
-DEST_MODULE_LOCATION[13]="/updates"
+DEST_MODULE_LOCATION[13]="/extra"
 
 BUILT_MODULE_NAME[14]="fuse-burn"
 BUILT_MODULE_LOCATION[14]="drivers/soc/tegra/fuse"
-DEST_MODULE_LOCATION[14]="/updates"
+DEST_MODULE_LOCATION[14]="/extra"
 
 BUILT_MODULE_NAME[15]="kfuse"
 BUILT_MODULE_LOCATION[15]="drivers/soc/tegra/fuse"
-DEST_MODULE_LOCATION[15]="/updates"
+DEST_MODULE_LOCATION[15]="/extra"
 
 BUILT_MODULE_NAME[16]="pci-epf-dma-test"
 BUILT_MODULE_LOCATION[16]="drivers/pci/endpoint/functions"
-DEST_MODULE_LOCATION[16]="/updates"
+DEST_MODULE_LOCATION[16]="/extra"
 
 BUILT_MODULE_NAME[17]="tegra-pcie-edma"
 BUILT_MODULE_LOCATION[17]="drivers/pci/controller"
-DEST_MODULE_LOCATION[17]="/updates"
+DEST_MODULE_LOCATION[17]="/extra"
 
 BUILT_MODULE_NAME[18]="pcie-tegra-vf"
 BUILT_MODULE_LOCATION[18]="drivers/pci/controller"
-DEST_MODULE_LOCATION[18]="/updates"
+DEST_MODULE_LOCATION[18]="/extra"
 
 BUILT_MODULE_NAME[19]="tegra-pcie-dma-test"
 BUILT_MODULE_LOCATION[19]="drivers/misc"
-DEST_MODULE_LOCATION[19]="/updates"
+DEST_MODULE_LOCATION[19]="/extra"
 
 BUILT_MODULE_NAME[20]="tegra-se"
 BUILT_MODULE_LOCATION[20]="drivers/crypto/tegra"
-DEST_MODULE_LOCATION[20]="/updates"
+DEST_MODULE_LOCATION[20]="/extra"
 
 BUILT_MODULE_NAME[21]="tegra-se-nvrng"
 BUILT_MODULE_LOCATION[21]="drivers/crypto"
-DEST_MODULE_LOCATION[21]="/updates"
+DEST_MODULE_LOCATION[21]="/extra"
 
 BUILT_MODULE_NAME[22]="nvidia-vrs-pseq"
 BUILT_MODULE_LOCATION[22]="drivers/mfd"
-DEST_MODULE_LOCATION[22]="/updates"
+DEST_MODULE_LOCATION[22]="/extra"
 
 BUILT_MODULE_NAME[23]="cpuidle-debugfs"
 BUILT_MODULE_LOCATION[23]="drivers/cpuidle"
-DEST_MODULE_LOCATION[23]="/updates"
+DEST_MODULE_LOCATION[23]="/extra"
 
 BUILT_MODULE_NAME[24]="pinctrl-tegra194-pexclk-padctrl"
 BUILT_MODULE_LOCATION[24]="drivers/pinctrl"
-DEST_MODULE_LOCATION[24]="/updates"
+DEST_MODULE_LOCATION[24]="/extra"
 
 AUTO_INSTALL="yes"

drivers/Makefile

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0-only
-# SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 LINUXINCLUDE += -I$(srctree.nvidia-oot)/include
 LINUXINCLUDE += -I$(srctree.nvidia-oot)/drivers/gpu/host1x/hw/
@@ -17,7 +17,9 @@ endif
 obj-m += c2c/
 obj-m += clink/
 obj-m += cpuidle/
+ifeq ($(CONFIG_SKIP_CRYPTO),)
 obj-m += crypto/
+endif
 ifdef CONFIG_PM_DEVFREQ
 obj-m += devfreq/
 endif
@@ -32,12 +34,10 @@ endif
 ifdef CONFIG_I2C
 obj-m += i2c/busses/
 obj-m += mfd/
-ifdef CONFIG_HTE
 ifdef CONFIG_IIO
 obj-m += bmi088/
 endif
 endif
-endif
 ifdef CONFIG_MEMORY
 obj-m += memory/
 endif
@@ -81,5 +81,7 @@ obj-m += virt/tegra/
 ifdef CONFIG_TEGRA_HOST1X
 obj-m += media/
 endif
+obj-m += staging/platform/tegra/gte/
+obj-m += staging/platform/tegra/gte_test/
 obj-m += nv-virtio/
 obj-m += usb/

drivers/bmi088/bmi088_core.c

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 /* Device tree example:
  *
@@ -7,15 +7,13 @@
  *   compatible = "bmi,bmi088";
  *   reg = <0x69>; // <-- Must be gyroscope I2C address
  *   accel_i2c_addr = <0x19>; // Must be specified
- *   accel_irq-gpios = <&tegra_gpio TEGRA_GPIO(BB, 0) GPIO_ACTIVE_HIGH>;
- *   gyro_irq-gpios = <&tegra_gpio TEGRA_GPIO(BB, 1) GPIO_ACTIVE_HIGH>;
+ *   accel_irq_gpio = <&tegra_gpio TEGRA_GPIO(BB, 0) GPIO_ACTIVE_HIGH>;
+ *   gyro_irq_gpio = <&tegra_gpio TEGRA_GPIO(BB, 1) GPIO_ACTIVE_HIGH>;
  *   accel_matrix    = [01 00 00 00 01 00 00 00 01];
  *   gyro_matrix        = [01 00 00 00 01 00 00 00 01];
  * };
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/device.h>
 #include <linux/version.h>
 #include <linux/i2c.h>
@@ -27,8 +25,8 @@
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
 #include <linux/of.h>
+#include <linux/tegra-gte.h>
 #include <linux/bitops.h>
-#include <linux/hte.h>
 #include "bmi_iio.h"
 
 #define BMI_NAME			"bmi088"
@@ -109,17 +107,22 @@
 
 #define BMI_PART_BMI088			(0)
 
-#define HTE_TIMEOUT			(msecs_to_jiffies(100))
-
 static const struct i2c_device_id bmi_i2c_device_ids[] = {
 	{ BMI_NAME, BMI_PART_BMI088 },
 	{},
 };
 
-struct bmi_gpio_irq {
-	struct gpio_desc *gpio_in;
+static char *gte_hw_str_t194 = "nvidia,tegra194-gte-aon";
+static char *gte_hw_str_t234 = "nvidia,tegra234-gte-aon";
+static struct device_node *gte_nd;
+
+struct bmi_gte_irq {
+	struct tegra_gte_ev_desc *gte;
 	const char *dev_name;
+	int gpio;
 	int irq;
+	u64 irq_ts;
+	u64 irq_ts_old;
 };
 
 struct bmi_reg_rd {
@@ -408,21 +411,18 @@ struct bmi_snsr {
 	struct sensor_cfg cfg;
 	unsigned int usr_cfg;
 	unsigned int period_us;
-	u64 irq_ts;
-	u64 irq_ts_old;
-	u64 seq;
-	struct completion hte_ts_cmpl;
-	struct bmi_gpio_irq gis;
-	struct bmi_state *st;
 };
 
 struct bmi_state {
 	struct i2c_client *i2c;
 	struct bmi_snsr snsrs[BMI_HW_N];
+	struct bmi_gte_irq gis[BMI_HW_N];
 	bool iio_init_done[BMI_HW_N];
 	unsigned int part;
 	unsigned int sts;
 	unsigned int errs_bus[BMI_HW_N];
+	unsigned int err_ts_thread[BMI_HW_N];
+	unsigned int sam_dropped[BMI_HW_N];
 	unsigned int enabled;
 	unsigned int suspend_en_st;
 	unsigned int hw_n;
@@ -537,36 +537,141 @@ static int bmi_i2c_wr(struct bmi_state *st, unsigned int hw, u8 reg, u8 val)
 	return ret;
 }
 
+static void bmi_gte_exit_gpio(struct bmi_gte_irq *ngi, unsigned int n)
+{
+	unsigned int i;
+
+	for (i = 0; i < n; i++) {
+		if (ngi[i].gpio >= 0)
+			gpio_free(ngi[i].gpio);
+	}
+}
+
+static int bmi_gte_init_gpio2irq(struct device *dev, struct bmi_gte_irq *ngi,
+				 unsigned int n)
+{
+	unsigned int i;
+	unsigned int prev;
+	int ret;
+
+	for (i = 0; i < n; i++) {
+		if (!gpio_is_valid(ngi[i].gpio) ||
+		    gpio_request(ngi[i].gpio, ngi[i].dev_name)) {
+			ret = -EPROBE_DEFER;
+			if (!i) {
+				goto out_no_prev;
+			} else {
+				prev = i - 1;
+				goto out;
+			}
+		}
+
+		ret = gpio_direction_input(ngi[i].gpio);
+		if (ret < 0) {
+			dev_err(dev, "%s gpio_dir_input(%d) ERR:%d\n",
+				ngi[i].dev_name, ngi[i].gpio, ret);
+			ret = -ENODEV;
+			if (!i)
+				prev = i;
+			else
+				prev = i - 1;
+
+			goto out;
+		}
+
+		ret = gpio_to_irq(ngi[i].gpio);
+		if (ret <= 0) {
+			dev_err(dev, "%s gpio_to_irq(%d) ERR:%d\n",
+				ngi[i].dev_name, ngi[i].gpio, ret);
+			ret = -ENODEV;
+			if (!i)
+				prev = i;
+			else
+				prev = i - 1;
+
+			goto out;
+		}
+
+		ngi[i].irq = ret;
+		ret = 0;
+	}
+
+	return ret;
+
+out:
+	bmi_gte_exit_gpio(ngi, prev);
+
+out_no_prev:
+
+	return ret;
+}
+
+static int bmi_gte_ts(struct bmi_gte_irq *ngi)
+{
+	struct tegra_gte_ev_desc *desc = (struct tegra_gte_ev_desc *)ngi->gte;
+	struct tegra_gte_ev_detail dtl;
+	int ret;
+
+	ret = tegra_gte_retrieve_event(desc, &dtl);
+	if (!ret)
+		ngi->irq_ts = dtl.ts_ns;
+
+	return ret;
+}
+
+static inline int bmi_gte_deinit(struct bmi_gte_irq *ngi)
+{
+	int ret = 0;
+
+	if (ngi->gte) {
+		ret = tegra_gte_unregister_event(ngi->gte);
+		ngi->gte = NULL;
+	}
+
+	return ret;
+}
+
+static void bmi_gte_gpio_exit(struct bmi_state *st, unsigned int n)
+{
+	unsigned int i;
+	struct bmi_gte_irq *ngi = st->gis;
+
+	if (gte_nd) {
+		of_node_put(gte_nd);
+		gte_nd = NULL;
+	}
+
+	for (i = 0; i < n; i++) {
+		bmi_gte_deinit(&ngi[i]);
+		if (ngi[i].gpio >= 0)
+			gpio_free(ngi[i].gpio);
+	}
+}
+
+static int bmi_gte_init(struct bmi_state *st, unsigned int id)
+{
+	int ret = 0;
+	struct bmi_gte_irq *ngi = st->gis;
+
+	if (!ngi[id].gte) {
+		ngi[id].gte = tegra_gte_register_event(gte_nd, ngi[id].gpio);
+		if (!ngi[id].gte)
+			ret = -ENODEV;
+	}
+
+	return ret;
+}
+
 static int bmi_setup_gpio(struct device *dev, struct bmi_state *st,
 			  unsigned int n)
 {
 	unsigned int i;
-	struct bmi_snsr *snsrs = st->snsrs;
-	int ret;
+	struct bmi_gte_irq *ngi = st->gis;
 
-	for (i = 0; i < n; i++) {
-		snsrs[i].gis.irq = -1;
-		if ((snsrs[i].gis.gpio_in)) {
-			ret = gpiod_direction_input(snsrs[i].gis.gpio_in);
+	for (i = 0; i < n; i++)
+		ngi[i].irq = -1;
 
-			if (ret < 0) {
-				dev_err(dev, "%s gpio_dir_input ERR:%d\n",
-						snsrs[i].gis.dev_name, ret);
-				return ret;
-			}
-
-			ret = gpiod_to_irq(snsrs[i].gis.gpio_in);
-			if (ret < 0) {
-				dev_err(dev, "%s gpio_to_irq ERR:%d\n",
-						snsrs[i].gis.dev_name, ret);
-				return ret;
-			}
-
-			snsrs[i].gis.irq = ret;
-		}
-	}
-
-	return 0;
+	return bmi_gte_init_gpio2irq(dev, ngi, n);
 }
 
 static int bmi_pm(struct bmi_state *st, int snsr_id, bool en)
@@ -862,32 +967,17 @@ static unsigned long bmi_gyr_irqflags(struct bmi_state *st)
 	return irqflags;
 }
 
-static enum hte_return process_hw_ts(struct hte_ts_data *ts, void *p)
-{
-	struct bmi_snsr *sensor = (struct bmi_snsr *)p;
-	struct bmi_state *st = sensor->st;
-
-	sensor->irq_ts = ts->tsc;
-	sensor->seq = ts->seq;
-
-	complete(&sensor->hte_ts_cmpl);
-
-	dev_dbg_ratelimited(&st->i2c->dev, "%s: seq %llu, ts:%llu\n",
-			    __func__, sensor->seq, sensor->irq_ts);
-
-	return HTE_CB_HANDLED;
-}
-
 static irqreturn_t bmi_irq_thread(int irq, void *dev_id)
 {
-	struct bmi_snsr *sensor = (struct bmi_snsr *)dev_id;
-	struct bmi_state *st = sensor->st;
+	struct bmi_state *st = (struct bmi_state *)dev_id;
 	unsigned int hw;
 	int ret;
 	u8 reg;
 	u8 sample[BMI_IMU_DATA];
+	int cnt = 0;
+	u64 ts_old;
 
-	if (irq == st->snsrs[BMI_HW_GYR].gis.irq) {
+	if (irq == st->gis[BMI_HW_GYR].irq) {
 		hw = BMI_HW_GYR;
 		reg = BMI_REG_GYR_DATA;
 	} else {
@@ -895,7 +985,7 @@ static irqreturn_t bmi_irq_thread(int irq, void *dev_id)
 		reg = BMI_REG_ACC_DATA;
 	}
 
-	/* Disable data ready interrupt before we read out data */
+	/* Disbale data ready interrupt before we read out data */
 	ret = bmi_hws[hw].fn_able(st, 0, true);
 	if (unlikely(ret)) {
 		dev_err_ratelimited(&st->i2c->dev,
@@ -903,31 +993,71 @@ static irqreturn_t bmi_irq_thread(int irq, void *dev_id)
 		goto err;
 	}
 
-	/* Wait for HTE IRQ to fetch the latest timestamp */
-	ret = wait_for_completion_interruptible_timeout(&sensor->hte_ts_cmpl, HTE_TIMEOUT);
-	if (!ret) {
-		dev_dbg_ratelimited(&st->i2c->dev,
-				    "sample dropped due to timeout");
-		goto err;
+	ts_old = st->gis[hw].irq_ts_old;
+
+	/*
+	 * There is a possibility that data ready IRQ may have caused GTE to
+	 * store the timestamps by the time this thread got a chance to run
+	 * and disable IRQ especially for the high data rate, in that case,
+	 * drain the GTE till it returns error and use last timestamp to
+	 * associate the data to be read.
+	 */
+	while (bmi_gte_ts(&st->gis[hw]) == 0)
+		cnt++;
+
+	/* Means we failed to get the ts in the first go */
+	if (!st->gis[hw].irq_ts && !cnt) {
+		dev_dbg(&st->i2c->dev, "sample dropped, gte get ts failed\n");
+		st->sam_dropped[hw]++;
+		goto out;
+	}
+
+	/*
+	 * If ts is same as old or 0, something is seriously wrong,
+	 * re-register with gte
+	 */
+	if ((st->gis[hw].irq_ts_old == st->gis[hw].irq_ts) ||
+	    (!st->gis[hw].irq_ts && cnt)) {
+		dev_dbg(&st->i2c->dev,
+			"ts issue for: %d, ts old: %llu, new: %llu\n",
+			hw, st->gis[hw].irq_ts_old, st->gis[hw].irq_ts);
+
+		st->err_ts_thread[hw]++;
+		st->sam_dropped[hw]++;
+		dev_dbg(&st->i2c->dev, "sample dropped due to ts issues\n");
+
+		/* Re-register with GTE */
+		bmi_gte_deinit(&st->gis[hw]);
+		ret = bmi_gte_init(st, hw);
+		if (ret) {
+			dev_err_ratelimited(&st->i2c->dev,
+					    "GTE re-registration failed: %d\n",
+					    hw);
+			goto err;
+		}
+
+		goto out;
 	}
 
 	mutex_lock(BMI_MUTEX(st->snsrs[hw].bmi_iio));
 
 	ret = bmi_i2c_rd(st, hw, reg, sizeof(sample), sample);
 
-	if (!ret) {
-		bmi_iio_push_buf(st->snsrs[hw].bmi_iio, sample,
-				 sensor->irq_ts);
-		dev_dbg(&st->i2c->dev, "%d, ts= %lld ts_old= %lld\n",
-			hw, sensor->irq_ts, sensor->irq_ts_old);
-
-		sensor->irq_ts_old = sensor->irq_ts;
-	}
-
 	mutex_unlock(BMI_MUTEX(st->snsrs[hw].bmi_iio));
 
-	/* Enable data ready interrupt */
+	if (!ret) {
+		bmi_iio_push_buf(st->snsrs[hw].bmi_iio, sample,
+				 st->gis[hw].irq_ts);
+		st->gis[hw].irq_ts_old = st->gis[hw].irq_ts;
+	}
+
+	dev_dbg(&st->i2c->dev, "%d, ts= %lld, ts_old=%lld\n",
+		hw, st->gis[hw].irq_ts, ts_old);
+
+out:
+	st->gis[hw].irq_ts = 0;
 	bmi_hws[hw].fn_able(st, 1, true);
+
 err:
 	return IRQ_HANDLED;
 }
@@ -942,7 +1072,7 @@ static int bmi_period(struct bmi_state *st, int snsr_id, bool range)
 					 range);
 }
 
-static int bmi_enable(void *client, int snsr_id, int enable)
+static int bmi_enable(void *client, int snsr_id, int enable, bool is_gte)
 {
 	struct bmi_state *st = (struct bmi_state *)client;
 	int ret;
@@ -954,10 +1084,20 @@ static int bmi_enable(void *client, int snsr_id, int enable)
 		return (st->enabled & (1 << snsr_id));
 
 	if (enable) {
+		if (is_gte) {
+			ret = bmi_gte_init(st, snsr_id);
+			if (ret)
+				return ret;
+		}
+
 		enable = st->enabled | (1 << snsr_id);
 		ret = bmi_pm(st, snsr_id, true);
-		if (ret < 0)
+		if (ret < 0) {
+			if (is_gte)
+				bmi_gte_deinit(&st->gis[snsr_id]);
+
 			return ret;
+		}
 
 		ret = bmi_period(st, snsr_id, true);
 		ret |= bmi_hws[snsr_id].fn_able(st, 1, false);
@@ -967,6 +1107,9 @@ static int bmi_enable(void *client, int snsr_id, int enable)
 		}
 	}
 
+	if (is_gte)
+		bmi_gte_deinit(&st->gis[snsr_id]);
+
 	ret = bmi_hws[snsr_id].fn_able(st, 0, false);
 	ret |= bmi_pm(st, snsr_id, false);
 
@@ -1159,6 +1302,11 @@ static int bmi_read_err(void *client, int snsr_id, char *buf)
 	t += snprintf(buf, PAGE_SIZE, "%s:\n", st->snsrs[snsr_id].cfg.name);
 	t += snprintf(buf + t, PAGE_SIZE - t,
 		      "I2C Bus Errors:%u\n", st->errs_bus[snsr_id]);
+	t += snprintf(buf + t, PAGE_SIZE - t,
+		      "GTE Timestamp Errors:%u\n", st->err_ts_thread[snsr_id]);
+	t += snprintf(buf + t, PAGE_SIZE - t,
+		      "Sample dropped:%u\n", st->sam_dropped[snsr_id]);
+
 	return t;
 }
 
@@ -1241,9 +1389,11 @@ static int __maybe_unused bmi_suspend(struct device *dev)
 	for (i = 0; i < st->hw_n; i++) {
 		mutex_lock(BMI_MUTEX(st->snsrs[i].bmi_iio));
 		/* check if sensor is enabled to begin with */
-		old_en_st = bmi_enable(st, st->snsrs[i].cfg.snsr_id, -1);
+		old_en_st = bmi_enable(st, st->snsrs[i].cfg.snsr_id, -1,
+				       false);
 		if (old_en_st) {
-			temp_ret = bmi_enable(st, st->snsrs[i].cfg.snsr_id, 0);
+			temp_ret = bmi_enable(st, st->snsrs[i].cfg.snsr_id, 0,
+					      false);
 			if (!temp_ret)
 				st->suspend_en_st |= old_en_st;
 
@@ -1265,7 +1415,8 @@ static int __maybe_unused bmi_resume(struct device *dev)
 	for (i = 0; i < st->hw_n; i++) {
 		mutex_lock(BMI_MUTEX(st->snsrs[i].bmi_iio));
 		if (st->suspend_en_st & (1 << st->snsrs[i].cfg.snsr_id))
-			ret |= bmi_enable(st, st->snsrs[i].cfg.snsr_id, 1);
+			ret |=  bmi_enable(st, st->snsrs[i].cfg.snsr_id, 1,
+					   false);
 		mutex_unlock(BMI_MUTEX(st->snsrs[i].bmi_iio));
 	}
 
@@ -1286,8 +1437,8 @@ static void bmi_shutdown(struct i2c_client *client)
 		if (st->iio_init_done[i])
 			mutex_lock(BMI_MUTEX(st->snsrs[i].bmi_iio));
 
-		if (bmi_enable(st, st->snsrs[i].cfg.snsr_id, -1))
-			bmi_enable(st, st->snsrs[i].cfg.snsr_id, 0);
+		if (bmi_enable(st, st->snsrs[i].cfg.snsr_id, -1, false))
+			bmi_enable(st, st->snsrs[i].cfg.snsr_id, 0, false);
 
 		if (st->iio_init_done[i]) {
 			mutex_unlock(BMI_MUTEX(st->snsrs[i].bmi_iio));
@@ -1303,6 +1454,7 @@ static void bmi_remove(void *data)
 
 	if (st != NULL) {
 		bmi_shutdown(client);
+		bmi_gte_gpio_exit(st, BMI_HW_N);
 		for (i = 0; i < st->hw_n; i++) {
 			if (st->iio_init_done[i])
 				bmi_iio_remove(st->snsrs[i].bmi_iio);
@@ -1328,18 +1480,8 @@ static int bmi_of_dt(struct bmi_state *st, struct device_node *dn)
 			return -ENODEV;
 	}
 
-
-	st->snsrs[BMI_HW_ACC].gis.gpio_in = devm_gpiod_get(&st->i2c->dev, "accel_irq", 0);
-	if (IS_ERR(st->snsrs[BMI_HW_ACC].gis.gpio_in)) {
-		dev_err(&st->i2c->dev, "accel_irq is not set in DT\n");
-		return PTR_ERR(st->snsrs[BMI_HW_ACC].gis.gpio_in);
-	}
-
-	st->snsrs[BMI_HW_GYR].gis.gpio_in = devm_gpiod_get(&st->i2c->dev, "gyro_irq", 0);
-	if (IS_ERR(st->snsrs[BMI_HW_GYR].gis.gpio_in)) {
-		dev_err(&st->i2c->dev, "gyro_irq is not set in DT\n");
-		return PTR_ERR(st->snsrs[BMI_HW_GYR].gis.gpio_in);
-	}
+	st->gis[BMI_HW_ACC].gpio = of_get_named_gpio(dn, "accel_irq_gpio", 0);
+	st->gis[BMI_HW_GYR].gpio = of_get_named_gpio(dn, "gyro_irq_gpio", 0);
 
 	if (!of_property_read_u32(dn, "accel_reg_0x53", &val32))
 		st->ra_0x53 = (u8)val32;
@@ -1379,11 +1521,14 @@ static int bmi_init(struct bmi_state *st, const struct i2c_device_id *id)
 	unsigned long irqflags;
 	unsigned int i;
 	int ret;
-	struct hte_ts_desc *desc;
 
 	if (id == NULL)
 		return -EINVAL;
 
+	/* driver specific defaults */
+	for (i = 0; i < BMI_HW_N; i++)
+		st->gis[i].gpio = -1;
+
 	st->ra_0x53 = BMI_INT1_OUT_ACTIVE_HIGH;
 	st->ra_0x54 = 0x00;
 	st->ra_0x58 = BMI_INT1_DTRDY;
@@ -1400,6 +1545,13 @@ static int bmi_init(struct bmi_state *st, const struct i2c_device_id *id)
 		return ret;
 	}
 
+	/*
+	 * Only interrupt mode is supported as we want hardware timestamps
+	 * from GTE.
+	 */
+	if (st->gis[BMI_HW_ACC].gpio < 0 || st->gis[BMI_HW_GYR].gpio < 0)
+		return -EINVAL;
+
 	st->part = id->driver_data;
 	st->i2c_addrs[BMI_HW_GYR] = st->i2c->addr;
 	ret = bmi_reset_all(st);
@@ -1428,63 +1580,31 @@ static int bmi_init(struct bmi_state *st, const struct i2c_device_id *id)
 		st->snsrs[i].cfg.part = bmi_i2c_device_ids[st->part].name;
 		st->snsrs[i].rrs = &bmi_hws[i].rrs[st->part];
 		bmi_max_range(st, i, st->snsrs[i].cfg.max_range.ival);
-		st->snsrs[i].gis.dev_name = st->snsrs[i].cfg.name;
+		st->gis[i].dev_name = st->snsrs[i].cfg.name;
+		st->gis[i].gte = NULL;
 		st->iio_init_done[i] = true;
-		st->snsrs[i].st = st;
-		init_completion(&st->snsrs[i].hte_ts_cmpl);
 	}
 
 	ret = bmi_setup_gpio(&st->i2c->dev, st, st->hw_n);
 	if (ret < 0)
 		return ret;
 
-
-	desc = devm_kzalloc(&st->i2c->dev, sizeof(*desc)*BMI_HW_N, GFP_KERNEL);
-	if (!desc)
-		return -ENOMEM;
-
-	for (i = 0; i < BMI_HW_N; i++) {
+	for (i = 0; i < st->hw_n; i++) {
 		if (bmi_hws[i].fn_irqflags) {
 			irqflags = bmi_hws[i].fn_irqflags(st);
 			ret = devm_request_threaded_irq(&st->i2c->dev,
-							st->snsrs[i].gis.irq,
+							st->gis[i].irq,
 							NULL,
 							bmi_irq_thread,
 							irqflags,
-							st->snsrs[i].gis.dev_name,
-							&st->snsrs[i]);
+							st->gis[i].dev_name,
+							st);
 			if (ret) {
 				dev_err(&st->i2c->dev,
 					"req_threaded_irq ERR %d\n", ret);
 				return ret;
 			}
 		}
-
-		ret = hte_init_line_attr(&desc[i], 0, 0, NULL,
-				st->snsrs[i].gis.gpio_in);
-		if (ret) {
-			dev_err(&st->i2c->dev,
-					"hte_init_line_attr ERR %d\n", ret);
-			return ret;
-		}
-
-		ret = hte_ts_get(&st->i2c->dev, &desc[i], i);
-
-		if (ret) {
-			dev_err(&st->i2c->dev,
-					"hte_ts_get ERR %d\n", ret);
-			return ret;
-		}
-
-		ret = devm_hte_request_ts_ns(&st->i2c->dev, &desc[i],
-						process_hw_ts, NULL,
-						&st->snsrs[i]);
-
-		if (ret) {
-			dev_err(&st->i2c->dev,
-					"devm_hte_request_ts_ns ERR %d\n", ret);
-			return ret;
-		}
 	}
 
 	/*
@@ -1494,11 +1614,20 @@ static int bmi_init(struct bmi_state *st, const struct i2c_device_id *id)
 	for (i = 0; i < st->hw_n; i++)
 		st->snsrs[i].period_us = st->snsrs[i].cfg.delay_us_max;
 
+	gte_nd = of_find_compatible_node(NULL, NULL, gte_hw_str_t194);
+	if (!gte_nd)
+		gte_nd = of_find_compatible_node(NULL, NULL, gte_hw_str_t234);
+
+	if (!gte_nd) {
+		dev_err(&st->i2c->dev, "Failed to find GTE node\n");
+		return -ENODEV;
+	}
+
 	return ret;
 }
 
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int bmi_probe(struct i2c_client *client)
 #else
 static int bmi_probe(struct i2c_client *client, const struct i2c_device_id *id)

drivers/bmi088/bmi088_iio.c

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 #include <linux/init.h>
 #include <linux/module.h>
@@ -164,9 +164,6 @@ int bmi_iio_push_buf(struct iio_dev *indio_dev, unsigned char *data, u64 ts)
 	if (!indio_dev || !data)
 		return -EINVAL;
 
-	if (!indio_dev->active_scan_mask)
-		return -EINVAL;
-
 	st = iio_priv(indio_dev);
 	if (!st)
 		return -EINVAL;
@@ -204,7 +201,8 @@ static int bmi_iio_enable(struct iio_dev *indio_dev, bool en)
 	int bit;
 
 	if (!en)
-		return st->fn_dev->enable(st->client, st->cfg->snsr_id, 0);
+		return st->fn_dev->enable(st->client, st->cfg->snsr_id,
+					  0, true);
 
 	if (indio_dev->num_channels > 1) {
 		for_each_set_bit(bit, indio_dev->active_scan_mask,
@@ -215,7 +213,7 @@ static int bmi_iio_enable(struct iio_dev *indio_dev, bool en)
 	}
 
 
-	return st->fn_dev->enable(st->client, st->cfg->snsr_id, enable);
+	return st->fn_dev->enable(st->client, st->cfg->snsr_id, enable, true);
 }
 
 static ssize_t bmi_iio_attr_store(struct device *dev,
@@ -352,7 +350,7 @@ static inline int bmi_iio_check_enable(struct bmi_iio_state *st)
 	if (!st->fn_dev->enable)
 		return -EINVAL;
 
-	return st->fn_dev->enable(st->client, st->cfg->snsr_id, -1);
+	return st->fn_dev->enable(st->client, st->cfg->snsr_id, -1, false);
 }
 
 static int bmi_iio_read_raw(struct iio_dev *indio_dev,

drivers/bmi088/bmi_iio.h

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2023-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 
 #ifndef _BMI_IIO_H_
@@ -39,7 +39,7 @@ struct sensor_cfg {
 
 struct iio_fn_dev {
 	unsigned int *sts;
-	int (*enable)(void *client, int snsr_id, int enable);
+	int (*enable)(void *client, int snsr_id, int enable, bool is_gte);
 	int (*freq_read)(void *client, int snsr_id, int *val, int *val2);
 	int (*freq_write)(void *client, int snsr_id, int val, int val2);
 	int (*scale_write)(void *client, int snsr_id, int val, int val2);

drivers/clk/tegra/clk-bpmp.c

@@ -1,5 +1,7 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ */
 
 #include <linux/clk-provider.h>
 #include <linux/device.h>
@@ -364,7 +366,7 @@ static int tegra_bpmp_clk_get_info(struct tegra_bpmp *bpmp, unsigned int id,
 	if (err < 0)
 		return err;
 
-	strscpy(info->name, response.name, MRQ_CLK_NAME_MAXLEN);
+	strlcpy(info->name, response.name, MRQ_CLK_NAME_MAXLEN);
 	info->num_parents = response.num_parents;
 
 	for (i = 0; i < info->num_parents; i++)

drivers/crypto/Makefile

@@ -5,9 +5,7 @@ ifdef CONFIG_TEGRA_HOST1X
 obj-m += tegra-hv-vse-safety.o
 obj-m += tegra-nvvse-cryptodev.o
 ifdef CONFIG_CRYPTO_ENGINE
-ifndef CONFIG_SKIP_CRYPTO
 obj-m += tegra/
 endif
 endif
-endif
 obj-m += tegra-se-nvrng.o

drivers/crypto/tegra-hv-vse-safety.c

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * Copyright (c) 2019-2024, NVIDIA Corporation. All Rights Reserved.
+ * Copyright (c) 2019-2023, NVIDIA Corporation. All Rights Reserved.
  *
  * Cryptographic API.
  */
@@ -15,8 +15,8 @@
 #include <linux/dma-mapping.h>
 #include <linux/hw_random.h>
 #include <linux/io.h>
+#include <linux/of.h>
 #include <linux/of_device.h>
-#include <linux/of_platform.h>
 #include <linux/mutex.h>
 #include <linux/types.h>
 #include <linux/errno.h>

drivers/crypto/tegra/tegra-se-aes.c

@@ -1,11 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 /*
  * Crypto driver to handle block cipher algorithms using NVIDIA Security Engine.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/host1x-next.h>
@@ -25,9 +23,7 @@
 #include "tegra-se.h"
 
 struct tegra_aes_ctx {
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	struct crypto_engine_ctx enginectx;
-#endif
 	struct tegra_se *se;
 	u32 alg;
 	u32 keylen;
@@ -45,9 +41,7 @@ struct tegra_aes_reqctx {
 };
 
 struct tegra_aead_ctx {
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	struct crypto_engine_ctx enginectx;
-#endif
 	struct tegra_se *se;
 	unsigned int authsize;
 	u32 alg;
@@ -72,9 +66,7 @@ struct tegra_aead_reqctx {
 };
 
 struct tegra_cmac_ctx {
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	struct crypto_engine_ctx enginectx;
-#endif
 	struct crypto_shash *fallback_tfm;
 	struct tegra_se *se;
 	unsigned int alg;
@@ -310,12 +302,6 @@ static int tegra_aes_do_one_req(struct crypto_engine *engine, void *areq)
 	struct tegra_se *se;
 	int ret;
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	ret = tegra_aes_prep_req(engine, areq);
-	if (ret != 0)
-		return ret;
-#endif
-
 	req = container_of(areq, struct skcipher_request, base);
 	rctx = skcipher_request_ctx(req);
 	ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req));
@@ -350,12 +336,6 @@ static int tegra_aes_do_one_req(struct crypto_engine *engine, void *areq)
 
 	crypto_finalize_skcipher_request(se->engine, req, ret);
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	if (ret != 0)
-		return ret;
-
-	ret = tegra_aes_unprep_req(engine, areq);
-#endif
 	return ret;
 }
 
@@ -367,11 +347,7 @@ static int tegra_aes_cra_init(struct crypto_skcipher *tfm)
 	const char *algname;
 	int ret;
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	se_alg = container_of(alg, struct tegra_se_alg, alg.skcipher.base);
-#else
 	se_alg = container_of(alg, struct tegra_se_alg, alg.skcipher);
-#endif
 
 	crypto_skcipher_set_reqsize(tfm, sizeof(struct tegra_aes_reqctx));
 
@@ -388,11 +364,9 @@ static int tegra_aes_cra_init(struct crypto_skcipher *tfm)
 	}
 
 	ctx->alg = ret;
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	ctx->enginectx.op.prepare_request = tegra_aes_prep_req;
 	ctx->enginectx.op.do_one_request = tegra_aes_do_one_req;
 	ctx->enginectx.op.unprepare_request = tegra_aes_unprep_req;
-#endif
 
 	return 0;
 }
@@ -520,9 +494,6 @@ static int tegra_aes_decrypt(struct skcipher_request *req)
 static struct tegra_se_alg tegra_aes_algs[] = {
 	{
 		.alg.skcipher = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_aes_cra_init,
 			.exit			= tegra_aes_cra_exit,
 			.setkey			= tegra_xts_setkey,
@@ -543,16 +514,9 @@ static struct tegra_se_alg tegra_aes_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_aes_do_one_req,
-#endif
 		}
 	}, {
 		.alg.skcipher = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_aes_cra_init,
 			.exit			= tegra_aes_cra_exit,
 			.setkey			= tegra_aes_setkey,
@@ -573,16 +537,9 @@ static struct tegra_se_alg tegra_aes_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_aes_do_one_req,
-#endif
 		}
 	}, {
 		.alg.skcipher = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_aes_cra_init,
 			.exit			= tegra_aes_cra_exit,
 			.setkey			= tegra_aes_setkey,
@@ -603,16 +560,9 @@ static struct tegra_se_alg tegra_aes_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_aes_do_one_req,
-#endif
 		}
 	}, {
 		.alg.skcipher = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_aes_cra_init,
 			.exit			= tegra_aes_cra_exit,
 			.setkey			= tegra_aes_setkey,
@@ -633,16 +583,9 @@ static struct tegra_se_alg tegra_aes_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_aes_do_one_req,
-#endif
 		}
 	}, {
 		.alg.skcipher = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_aes_cra_init,
 			.exit			= tegra_aes_cra_exit,
 			.setkey			= tegra_aes_setkey,
@@ -663,10 +606,6 @@ static struct tegra_se_alg tegra_aes_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_aes_do_one_req,
-#endif
 		}
 	},
 };
@@ -1250,11 +1189,6 @@ static int tegra_ccm_crypt_init(struct aead_request *req, struct tegra_se *se,
 	return 0;
 }
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-static int tegra_aead_prep_req(struct crypto_engine *engine, void *areq);
-static int tegra_aead_unprep_req(struct crypto_engine *engine, void *areq);
-#endif
-
 static int tegra_ccm_do_one_req(struct crypto_engine *engine, void *areq)
 {
 	struct aead_request *req = container_of(areq, struct aead_request, base);
@@ -1264,12 +1198,6 @@ static int tegra_ccm_do_one_req(struct crypto_engine *engine, void *areq)
 	struct tegra_se *se = ctx->se;
 	int ret;
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	ret = tegra_aead_prep_req(engine, areq);
-	if (ret != 0)
-		return ret;
-#endif
-
 	ret = tegra_ccm_crypt_init(req, se, rctx);
 	if (ret)
 		goto out;
@@ -1303,11 +1231,6 @@ static int tegra_ccm_do_one_req(struct crypto_engine *engine, void *areq)
 out:
 	crypto_finalize_aead_request(se->engine, req, ret);
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	ret = tegra_aead_unprep_req(engine, areq);
-	if (ret != 0)
-		return ret;
-#endif
 	return 0;
 }
 
@@ -1319,12 +1242,6 @@ static int tegra_gcm_do_one_req(struct crypto_engine *engine, void *areq)
 	struct tegra_aead_reqctx *rctx = aead_request_ctx(req);
 	int ret;
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	ret = tegra_aead_prep_req(engine, areq);
-	if (ret != 0)
-		return ret;
-#endif
-
 	req = container_of(areq, struct aead_request, base);
 
 	rctx->src_sg = req->src;
@@ -1364,11 +1281,6 @@ static int tegra_gcm_do_one_req(struct crypto_engine *engine, void *areq)
 
 out:
 	crypto_finalize_aead_request(ctx->se->engine, req, ret);
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	ret = tegra_aead_unprep_req(engine, areq);
-	if (ret != 0)
-		return ret;
-#endif
 	return 0;
 }
 
@@ -1426,11 +1338,7 @@ static int tegra_ccm_cra_init(struct crypto_aead *tfm)
 
 	algname = crypto_tfm_alg_name(&tfm->base);
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	se_alg = container_of(alg, struct tegra_se_alg, alg.aead.base);
-#else
 	se_alg = container_of(alg, struct tegra_se_alg, alg.aead);
-#endif
 
 	crypto_aead_set_reqsize(tfm, sizeof(struct tegra_aead_reqctx));
 
@@ -1438,11 +1346,9 @@ static int tegra_ccm_cra_init(struct crypto_aead *tfm)
 	ctx->key_id = 0;
 	ctx->alg = se_algname_to_algid(algname);
 
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	ctx->enginectx.op.prepare_request = tegra_aead_prep_req;
 	ctx->enginectx.op.do_one_request = tegra_ccm_do_one_req;
 	ctx->enginectx.op.unprepare_request = tegra_aead_unprep_req;
-#endif
 
 	return 0;
 }
@@ -1477,11 +1383,7 @@ static int tegra_gcm_cra_init(struct crypto_aead *tfm)
 	const char *algname;
 
 	algname = crypto_tfm_alg_name(&tfm->base);
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	se_alg = container_of(alg, struct tegra_se_alg, alg.aead.base);
-#else
 	se_alg = container_of(alg, struct tegra_se_alg, alg.aead);
-#endif
 
 	crypto_aead_set_reqsize(tfm, sizeof(struct tegra_aead_reqctx));
 
@@ -1489,11 +1391,9 @@ static int tegra_gcm_cra_init(struct crypto_aead *tfm)
 	ctx->key_id = 0;
 	ctx->alg = se_algname_to_algid(algname);
 
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	ctx->enginectx.op.prepare_request = tegra_aead_prep_req;
 	ctx->enginectx.op.do_one_request = tegra_gcm_do_one_req;
 	ctx->enginectx.op.unprepare_request = tegra_aead_unprep_req;
-#endif
 
 	return 0;
 }
@@ -1737,11 +1637,7 @@ static int tegra_cmac_cra_init(struct crypto_tfm *tfm)
 	const char *algname;
 
 	algname = crypto_tfm_alg_name(tfm);
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	se_alg = container_of(alg, struct tegra_se_alg, alg.ahash.base);
-#else
 	se_alg = container_of(alg, struct tegra_se_alg, alg.ahash);
-#endif
 
 	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
 				 sizeof(struct tegra_cmac_reqctx));
@@ -1749,11 +1645,9 @@ static int tegra_cmac_cra_init(struct crypto_tfm *tfm)
 	ctx->se = se_alg->se_dev;
 	ctx->key_id = 0;
 	ctx->alg = se_algname_to_algid(algname);
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	ctx->enginectx.op.prepare_request = NULL;
 	ctx->enginectx.op.do_one_request = tegra_cmac_do_one_req;
 	ctx->enginectx.op.unprepare_request = NULL;
-#endif
 
 	ctx->fallback_tfm = crypto_alloc_shash(algname, 0,
 				    CRYPTO_ALG_NEED_FALLBACK);
@@ -1898,9 +1792,6 @@ static int tegra_cmac_import(struct ahash_request *req, const void *in)
 static struct tegra_se_alg tegra_aead_algs[] = {
 	{
 		.alg.aead = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_gcm_cra_init,
 			.exit			= tegra_aead_cra_exit,
 			.setkey			= tegra_aead_setkey,
@@ -1918,16 +1809,9 @@ static struct tegra_se_alg tegra_aead_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_gcm_do_one_req,
-#endif
 		}
 	}, {
 		.alg.aead = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init			= tegra_ccm_cra_init,
 			.exit			= tegra_aead_cra_exit,
 			.setkey			= tegra_aead_setkey,
@@ -1946,10 +1830,6 @@ static struct tegra_se_alg tegra_aead_algs[] = {
 				.cra_alignmask	   = 0,
 				.cra_module	   = THIS_MODULE,
 			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_ccm_do_one_req,
-#endif
 		}
 	}
 };
@@ -1957,9 +1837,6 @@ static struct tegra_se_alg tegra_aead_algs[] = {
 static struct tegra_se_alg tegra_cmac_algs[] = {
 	{
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_cmac_init,
 			.setkey	= tegra_cmac_setkey,
 			.update = tegra_cmac_update,
@@ -1982,11 +1859,7 @@ static struct tegra_se_alg tegra_cmac_algs[] = {
 				.cra_module = THIS_MODULE,
 				.cra_init = tegra_cmac_cra_init,
 				.cra_exit = tegra_cmac_cra_exit,
-			},
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_cmac_do_one_req,
-#endif
+			}
 		}
 	}
 };
@@ -1999,45 +1872,30 @@ int tegra_init_aes(struct tegra_se *se)
 
 	for (i = 0; i < ARRAY_SIZE(tegra_aes_algs); i++) {
 		tegra_aes_algs[i].se_dev = se;
-		ret = CRYPTO_REGISTER(skcipher, &tegra_aes_algs[i].alg.skcipher);
+		ret = crypto_register_skcipher(&tegra_aes_algs[i].alg.skcipher);
 		if (ret) {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			dev_err(se->dev, "failed to register %s\n",
-				tegra_aes_algs[i].alg.skcipher.base.base.cra_name);
-#else
 			dev_err(se->dev, "failed to register %s\n",
 				tegra_aes_algs[i].alg.skcipher.base.cra_name);
-#endif
 			goto err_aes;
 		}
 	}
 
 	for (i = 0; i < ARRAY_SIZE(tegra_aead_algs); i++) {
 		tegra_aead_algs[i].se_dev = se;
-		ret = CRYPTO_REGISTER(aead, &tegra_aead_algs[i].alg.aead);
+		ret = crypto_register_aead(&tegra_aead_algs[i].alg.aead);
 		if (ret) {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			dev_err(se->dev, "failed to register %s\n",
-				tegra_aead_algs[i].alg.aead.base.base.cra_name);
-#else
 			dev_err(se->dev, "failed to register %s\n",
 				tegra_aead_algs[i].alg.aead.base.cra_name);
-#endif
 			goto err_aead;
 		}
 	}
 
 	for (i = 0; i < ARRAY_SIZE(tegra_cmac_algs); i++) {
 		tegra_cmac_algs[i].se_dev = se;
-		ret = CRYPTO_REGISTER(ahash, &tegra_cmac_algs[i].alg.ahash);
+		ret = crypto_register_ahash(&tegra_cmac_algs[i].alg.ahash);
 		if (ret) {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 			dev_err(se->dev, "failed to register %s\n",
-				tegra_cmac_algs[i].alg.ahash.base.halg.base.cra_name);
-#else
-			dev_err(se->dev, "failed to register %s\n",
-				tegra_cmac_algs[i].alg.ahash.halg.base.cra_name);
-#endif
+			tegra_cmac_algs[i].alg.ahash.halg.base.cra_name);
 			goto err_cmac;
 		}
 	}
@@ -2048,17 +1906,17 @@ int tegra_init_aes(struct tegra_se *se)
 
 err_cmac:
 	for (--i; i >= 0; i--)
-		CRYPTO_UNREGISTER(ahash, &tegra_cmac_algs[i].alg.ahash);
+		crypto_unregister_ahash(&tegra_cmac_algs[i].alg.ahash);
 
 	i = ARRAY_SIZE(tegra_aead_algs);
 err_aead:
 	for (--i; i >= 0; i--)
-		CRYPTO_UNREGISTER(aead, &tegra_aead_algs[i].alg.aead);
+		crypto_unregister_aead(&tegra_aead_algs[i].alg.aead);
 
 	i = ARRAY_SIZE(tegra_aes_algs);
 err_aes:
 	for (--i; i >= 0; i--)
-		CRYPTO_UNREGISTER(skcipher, &tegra_aes_algs[i].alg.skcipher);
+		crypto_unregister_skcipher(&tegra_aes_algs[i].alg.skcipher);
 
 	return ret;
 }
@@ -2068,12 +1926,12 @@ void tegra_deinit_aes(void)
 	int i;
 
 	for (i = 0; i < ARRAY_SIZE(tegra_aes_algs); i++)
-		CRYPTO_UNREGISTER(skcipher, &tegra_aes_algs[i].alg.skcipher);
+		crypto_unregister_skcipher(&tegra_aes_algs[i].alg.skcipher);
 
 	for (i = 0; i < ARRAY_SIZE(tegra_aead_algs); i++)
-		CRYPTO_UNREGISTER(aead, &tegra_aead_algs[i].alg.aead);
+		crypto_unregister_aead(&tegra_aead_algs[i].alg.aead);
 
 	for (i = 0; i < ARRAY_SIZE(tegra_cmac_algs); i++)
-		CRYPTO_UNREGISTER(ahash, &tegra_cmac_algs[i].alg.ahash);
+		crypto_unregister_ahash(&tegra_cmac_algs[i].alg.ahash);
 
 }

drivers/crypto/tegra/tegra-se-hash.c

@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 /*
  * Crypto driver to handle HASH algorithms using NVIDIA Security Engine.
  */
 
-#include <nvidia/conftest.h>
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/host1x-next.h>
@@ -24,9 +23,7 @@
 #include "tegra-se.h"
 
 struct tegra_sha_ctx {
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	struct crypto_engine_ctx enginectx;
-#endif
 	struct crypto_ahash *fallback_tfm;
 	struct tegra_se *se;
 	unsigned int alg;
@@ -417,11 +414,7 @@ static int tegra_sha_cra_init(struct crypto_tfm *tfm)
 	const char *algname;
 
 	algname = crypto_tfm_alg_name(tfm);
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-	se_alg = container_of(alg, struct tegra_se_alg, alg.ahash.base);
-#else
 	se_alg = container_of(alg, struct tegra_se_alg, alg.ahash);
-#endif
 
 	crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
 				 sizeof(struct tegra_sha_reqctx));
@@ -430,11 +423,9 @@ static int tegra_sha_cra_init(struct crypto_tfm *tfm)
 	ctx->fallback = false;
 	ctx->key_id = 0;
 	ctx->alg = se_algname_to_algid(algname);
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 	ctx->enginectx.op.prepare_request = NULL;
 	ctx->enginectx.op.do_one_request = tegra_sha_do_one_req;
 	ctx->enginectx.op.unprepare_request = NULL;
-#endif
 
 	if (se_alg->alg_base)
 		tegra_sha_init_fallback(ctx, algname);
@@ -501,7 +492,7 @@ digbuf_fail:
 	return -ENOMEM;
 }
 
-static int tegra_hmac_fallback_setkey(struct tegra_sha_ctx *ctx, const u8 *key,
+int tegra_hmac_fallback_setkey(struct tegra_sha_ctx *ctx, const u8 *key,
 				      unsigned int keylen)
 {
 	if (!ctx->fallback_tfm) {
@@ -617,9 +608,6 @@ static int tegra_sha_import(struct ahash_request *req, const void *in)
 static struct tegra_se_alg tegra_hash_algs[] = {
 	{
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -642,16 +630,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -674,16 +655,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -706,16 +680,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -738,16 +705,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -770,16 +730,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -802,16 +755,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -834,16 +780,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -866,16 +805,9 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -898,17 +830,10 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg_base = "sha224",
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -932,17 +857,10 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg_base = "sha256",
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -966,17 +884,10 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg_base = "sha384",
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -1000,17 +911,10 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}, {
 		.alg_base = "sha512",
 		.alg.ahash = {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			.base = {
-#endif
 			.init = tegra_sha_init,
 			.update = tegra_sha_update,
 			.final = tegra_sha_final,
@@ -1034,10 +938,6 @@ static struct tegra_se_alg tegra_hash_algs[] = {
 				.cra_init = tegra_sha_cra_init,
 				.cra_exit = tegra_sha_cra_exit,
 			}
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-			},
-			.op.do_one_request = tegra_sha_do_one_req,
-#endif
 		}
 	}
 };
@@ -1084,15 +984,10 @@ int tegra_init_hash(struct tegra_se *se)
 	for (i = 0; i < ARRAY_SIZE(tegra_hash_algs); i++) {
 
 		tegra_hash_algs[i].se_dev = se;
-		ret = CRYPTO_REGISTER(ahash, &tegra_hash_algs[i].alg.ahash);
+		ret = crypto_register_ahash(&tegra_hash_algs[i].alg.ahash);
 		if (ret) {
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 			dev_err(se->dev, "failed to register %s\n",
-				tegra_hash_algs[i].alg.ahash.base.halg.base.cra_name);
-#else
-			dev_err(se->dev, "failed to register %s\n",
-				tegra_hash_algs[i].alg.ahash.halg.base.cra_name);
-#endif
+			tegra_hash_algs[i].alg.ahash.halg.base.cra_name);
 			goto sha_err;
 		}
 	}
@@ -1103,7 +998,7 @@ int tegra_init_hash(struct tegra_se *se)
 
 sha_err:
 	for (--i; i >= 0; i--)
-		CRYPTO_UNREGISTER(ahash, &tegra_hash_algs[i].alg.ahash);
+		crypto_unregister_ahash(&tegra_hash_algs[i].alg.ahash);
 
 	return ret;
 }
@@ -1114,5 +1009,5 @@ void tegra_deinit_hash(void)
 	int i;
 
 	for (i = 0; i < ARRAY_SIZE(tegra_hash_algs); i++)
-		CRYPTO_UNREGISTER(ahash, &tegra_hash_algs[i].alg.ahash);
+		crypto_unregister_ahash(&tegra_hash_algs[i].alg.ahash);
 }

drivers/crypto/tegra/tegra-se.h

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 /*
  * Header file for NVIDIA Security Engine driver.
  */
@@ -18,9 +18,6 @@
 #include <crypto/sm3.h>
 #include <crypto/skcipher.h>
 #include <nvidia/conftest.h>
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-#include <crypto/engine.h>
-#endif
 
 #define SE_MAX_INSTANCES				3
 #define SE_OWNERSHIP					0x14
@@ -362,21 +359,6 @@
 #define SHA_UPDATE	BIT(1)
 #define SHA_FINAL	BIT(2)
 
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-#define CRYPTO_REGISTER(alg, x) \
-		crypto_engine_register_##alg(x)
-#else
-#define CRYPTO_REGISTER(alg, x) \
-		crypto_register_##alg(x)
-#endif
-
-#ifdef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
-#define CRYPTO_UNREGISTER(alg, x) \
-		crypto_engine_unregister_##alg(x)
-#else
-#define CRYPTO_UNREGISTER(alg, x) \
-		crypto_unregister_##alg(x)
-#endif
 
 /* Security Engine operation modes */
 enum se_aes_alg {
@@ -416,15 +398,9 @@ struct tegra_se_alg {
 	const char *alg_base;
 
 	union {
-#ifndef NV_CONFTEST_REMOVE_STRUCT_CRYPTO_ENGINE_CTX
 		struct skcipher_alg	skcipher;
 		struct aead_alg		aead;
 		struct ahash_alg	ahash;
-#else
-		struct skcipher_engine_alg	skcipher;
-		struct aead_engine_alg		aead;
-		struct ahash_engine_alg	ahash;
-#endif
 	} alg;
 };
 

drivers/firmware/tegra/Makefile

@@ -1,14 +1,16 @@
 # SPDX-License-Identifier: GPL-2.0
-# Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 #
 # Makefile for Extended IVC Driver and BPMP driver
 #
 
 obj-m		+= ivc_ext.o
+ifneq ($(CONFIG_TEGRA_IVC_LEGACY_DISABLE),y)
 tegra_bpmp-y	+= ../../clk/tegra/clk-bpmp.o
 tegra_bpmp-y	+= ../../reset/tegra/reset-bpmp.o
 tegra_bpmp-y	+= ../../soc/tegra/powergate-bpmp.o
 tegra_bpmp-$(CONFIG_DEBUG_FS)	+= bpmp-debugfs.o
 tegra_bpmp-y	+= bpmp-tegra186-hv.o
-obj-m 		+= tegra_bpmp.o
+obj-m 		+= tegra_bpmp.o
+endif

drivers/firmware/tegra/bpmp-tegra186-hv.c

@@ -1,10 +1,8 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
- * Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/of_address.h>
@@ -84,11 +82,7 @@ static void tegra_bpmp_handle_mrq(struct tegra_bpmp *bpmp,
 
 static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel)
 {
-#if defined(NV_TEGRA_IVC_STRUCT_HAS_IOSYS_MAP)
-	unsigned long flags = tegra_bpmp_mb_read_field(&channel->ob, flags);
-#else
 	unsigned long flags = channel->ob->flags;
-#endif
 
 	if ((flags & MSG_RING) == 0)
 		return;
@@ -122,15 +116,8 @@ void tegra_bpmp_handle_rx(struct tegra_bpmp *bpmp)
 
 	/* If supported incoming channel */
 	if (bpmp->soc->channels.cpu_rx.count == MAX_POSSIBLE_RX_CHANNEL) {
-#if defined(NV_TEGRA_IVC_STRUCT_HAS_IOSYS_MAP)
-		if (tegra_bpmp_is_request_ready(channel)) {
-			unsigned int mrq = tegra_bpmp_mb_read_field(&channel->ib, code);
-			tegra_bpmp_handle_mrq(bpmp, mrq, channel);
-		}
-#else
 		if (tegra_bpmp_is_request_ready(channel))
 			tegra_bpmp_handle_mrq(bpmp, channel->ib->code, channel);
-#endif
         }
 
 	spin_lock(&bpmp->lock);
@@ -211,20 +198,12 @@ static bool tegra186_bpmp_hv_is_message_ready(struct tegra_bpmp_channel *channel
 	void *frame;
 
 	frame = tegra_hv_ivc_read_get_next_frame(hv_ivc);
-#if defined(NV_TEGRA_IVC_STRUCT_HAS_IOSYS_MAP)
-	if (IS_ERR(frame)) {
-		iosys_map_clear(&channel->ib);
-		return false;
-	}
-	iosys_map_set_vaddr(&channel->ib, frame);
-#else
 	if (IS_ERR(frame)) {
 		channel->ib = NULL;
 		return false;
 	}
 
 	channel->ib = frame;
-#endif
 
 	return true;
 }
@@ -242,20 +221,12 @@ static bool tegra186_hv_bpmp_is_channel_free(struct tegra_bpmp_channel *channel)
 	void *frame;
 
 	frame = tegra_hv_ivc_write_get_next_frame(hv_ivc);
-#if defined(NV_TEGRA_IVC_STRUCT_HAS_IOSYS_MAP)
-	if (IS_ERR(frame)) {
-		iosys_map_clear(&channel->ob);
-		return false;
-	}
-	iosys_map_set_vaddr(&channel->ob, frame);
-#else
 	if (IS_ERR(frame)) {
 		channel->ob = NULL;
 		return false;
 	}
 
 	channel->ob = frame;
-#endif
 
 	return true;
 }
@@ -461,23 +432,13 @@ static void tegra_bpmp_mrq_handle_ping(unsigned int mrq,
 				       struct tegra_bpmp_channel *channel,
 				       void *data)
 {
-	struct mrq_ping_response response;
-#if defined(NV_TEGRA_IVC_STRUCT_HAS_IOSYS_MAP)
-	struct mrq_ping_request request;
-
-	tegra_bpmp_mb_read(&request, &channel->ib, sizeof(request));
-
-	memset(&response, 0, sizeof(response));
-	response.reply = request.challenge << 1;
-#else
 	struct mrq_ping_request *request;
+	struct mrq_ping_response response;
 
 	request = (struct mrq_ping_request *)channel->ib->data;
 
 	memset(&response, 0, sizeof(response));
 	response.reply = request->challenge << 1;
-#endif
-
 
 	tegra_bpmp_mrq_return(channel, 0, &response, sizeof(response));
 }

drivers/gpu/drm/tegra/Makefile

@@ -1,11 +1,11 @@
 # SPDX-License-Identifier: GPL-2.0-only
-# Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
 
 ccflags-$(CONFIG_DRM_TEGRA_DEBUG) += -DDEBUG
 ccflags-y += -I$(srctree.nvidia-oot)/drivers/gpu/drm/tegra/include
 ccflags-y += -I$(srctree.hwpm)/include
 
-tegra-drm-y := \
+tegra-drm-next-y := \
 	drm.o \
 	uapi.o \
 	submit.o \
@@ -37,6 +37,6 @@ tegra-drm-y := \
 	ofa.o \
 	virt.o
 
-tegra-drm-y += trace.o
+tegra-drm-next-y += trace.o
 
-obj-m := tegra-drm.o
+obj-m := tegra-drm-next.o

drivers/gpu/drm/tegra/dc.c

@@ -4,8 +4,6 @@
  * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/debugfs.h>
 #include <linux/delay.h>
@@ -14,7 +12,6 @@
 #include <linux/interconnect.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
-#include <linux/platform_device.h>
 #include <linux/pm_domain.h>
 #include <linux/pm_opp.h>
 #include <linux/pm_runtime.h>
@@ -1750,19 +1747,7 @@ static void tegra_dc_early_unregister(struct drm_crtc *crtc)
 	struct drm_minor *minor = crtc->dev->primary;
 	struct tegra_dc *dc = to_tegra_dc(crtc);
 
-#if defined(NV_DRM_DEBUGFS_REMOVE_FILES_HAS_ROOT_ARG) /* Linux v6.7 */
-	struct dentry *root;
-
-#ifdef CONFIG_DEBUG_FS
-	root = crtc->debugfs_entry;
-#else
-	root = NULL;
-#endif
-
-	drm_debugfs_remove_files(dc->debugfs_files, count, root, minor);
-#else
 	drm_debugfs_remove_files(dc->debugfs_files, count, minor);
-#endif
 	kfree(dc->debugfs_files);
 	dc->debugfs_files = NULL;
 }

drivers/gpu/drm/tegra/dpaux.c

@@ -11,7 +11,6 @@
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
-#include <linux/platform_device.h>
 #include <linux/pinctrl/pinconf-generic.h>
 #include <linux/pinctrl/pinctrl.h>
 #include <linux/pinctrl/pinmux.h>

drivers/gpu/drm/tegra/drm.c

@@ -26,7 +26,6 @@
 #include <drm/drm_ioctl.h>
 #include <drm/drm_prime.h>
 #include <drm/drm_vblank.h>
-#include <drm/tegra_drm-next.h>
 
 #if IS_ENABLED(CONFIG_ARM_DMA_USE_IOMMU)
 #include <asm/dma-iommu.h>
@@ -892,10 +891,8 @@ static const struct drm_driver tegra_drm_driver = {
 	.debugfs_init = tegra_debugfs_init,
 #endif
 
-#if NV_IS_EXPORT_SYMBOL_PRESENT_drm_gem_prime_handle_to_fd
+#if !defined(NV_UNEXPORT_FD_HANDLE_CONVERSION)
 	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
-#endif
-#if NV_IS_EXPORT_SYMBOL_PRESENT_drm_gem_prime_fd_to_handle
 	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
 #endif
 	.gem_prime_import = tegra_gem_prime_import,

drivers/gpu/drm/tegra/dsi.c

@@ -3,8 +3,6 @@
  * Copyright (C) 2013 NVIDIA Corporation
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/debugfs.h>
 #include <linux/delay.h>
@@ -257,14 +255,8 @@ static void tegra_dsi_early_unregister(struct drm_connector *connector)
 	unsigned int count = ARRAY_SIZE(debugfs_files);
 	struct tegra_dsi *dsi = to_dsi(output);
 
-#if defined(NV_DRM_DEBUGFS_REMOVE_FILES_HAS_ROOT_ARG) /* Linux v6.7 */
-	drm_debugfs_remove_files(dsi->debugfs_files, count,
-				 connector->debugfs_entry,
-				 connector->dev->primary);
-#else
 	drm_debugfs_remove_files(dsi->debugfs_files, count,
 				 connector->dev->primary);
-#endif
 	kfree(dsi->debugfs_files);
 	dsi->debugfs_files = NULL;
 }

drivers/gpu/drm/tegra/fb.c

@@ -11,7 +11,10 @@
 
 #include <linux/console.h>
 #include <linux/version.h>
+
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 5, 0)
 #include <linux/fb.h>
+#endif
 
 #include <drm/drm_fourcc.h>
 #include <drm/drm_framebuffer.h>
@@ -211,21 +214,24 @@ static int tegra_fb_mmap(struct fb_info *info, struct vm_area_struct *vma)
 	return __tegra_gem_mmap(&bo->gem, vma);
 }
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 5, 0)
+#if defined(NV_FB_DEFERRED_IO_OPS_RENAME)
+FB_GEN_DEFAULT_DEFERRED_IOMEM_OPS(tegra_fb,
+			       drm_fb_helper_damage_range,
+			       drm_fb_helper_damage_area)
+#else
+FB_GEN_DEFAULT_DEFERRED_IO_OPS(tegra_fb,
+			       drm_fb_helper_damage_range,
+			       drm_fb_helper_damage_area)
+#endif
+#endif
+
 static const struct fb_ops tegra_fb_ops = {
 	.owner = THIS_MODULE,
-#if defined(__FB_DEFAULT_DMAMEM_OPS_RDWR) /* Linux v6.6 */
-	__FB_DEFAULT_DMAMEM_OPS_RDWR,
-#elif defined(__FB_DEFAULT_SYS_OPS_RDWR) /* Linux v6.5 */
-	__FB_DEFAULT_SYS_OPS_RDWR,
-#else
-	.fb_read = drm_fb_helper_sys_read,
-	.fb_write = drm_fb_helper_sys_write,
-#endif
 	DRM_FB_HELPER_DEFAULT_OPS,
-#if defined(__FB_DEFAULT_DMAMEM_OPS_DRAW) /* Linux v6.6 */
-	__FB_DEFAULT_DMAMEM_OPS_DRAW,
-#elif defined(__FB_DEFAULT_SYS_OPS_DRAW) /* Linux v6.5 */
-	__FB_DEFAULT_SYS_OPS_DRAW,
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 5, 0)
+	__FB_DEFAULT_DEFERRED_OPS_RDWR(tegra_fb),
+	__FB_DEFAULT_DEFERRED_OPS_DRAW(tegra_fb),
 #else
 	.fb_fillrect = drm_fb_helper_sys_fillrect,
 	.fb_copyarea = drm_fb_helper_sys_copyarea,

drivers/gpu/drm/tegra/gem.c

@@ -15,6 +15,7 @@
 #include <linux/dma-buf.h>
 #include <linux/iommu.h>
 #include <linux/module.h>
+#include <linux/version.h>
 
 #include <drm/drm_drv.h>
 #include <drm/drm_prime.h>
@@ -583,7 +584,8 @@ int __tegra_gem_mmap(struct drm_gem_object *gem, struct vm_area_struct *vma)
 		 * and set the vm_pgoff (used as a fake buffer offset by DRM)
 		 * to 0 as we want to map the whole buffer.
 		 */
-#if defined(NV_VM_AREA_STRUCT_HAS_CONST_VM_FLAGS) /* Linux v6.3 */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0)) \
+		|| (defined(CONFIG_TEGRA_SYSTEM_TYPE_ACK) && (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)))
 		vm_flags_clear(vma, VM_PFNMAP);
 #else
 		vma->vm_flags &= ~VM_PFNMAP;
@@ -601,7 +603,8 @@ int __tegra_gem_mmap(struct drm_gem_object *gem, struct vm_area_struct *vma)
 	} else {
 		pgprot_t prot = vm_get_page_prot(vma->vm_flags);
 
-#if defined(NV_VM_AREA_STRUCT_HAS_CONST_VM_FLAGS) /* Linux v6.3 */
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0)) \
+		|| (defined(CONFIG_TEGRA_SYSTEM_TYPE_ACK) && (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)))
 		vm_flags_set(vma, VM_MIXEDMAP);
 		vm_flags_clear(vma, VM_PFNMAP);
 #else
@@ -724,6 +727,7 @@ static int tegra_gem_prime_vmap(struct dma_buf *buf, struct iosys_map *map)
 {
 	struct drm_gem_object *gem = buf->priv;
 	struct tegra_bo *bo = to_tegra_bo(gem);
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
 	void *vaddr;
 
 	vaddr = tegra_bo_mmap(&bo->base);
@@ -731,16 +735,21 @@ static int tegra_gem_prime_vmap(struct dma_buf *buf, struct iosys_map *map)
 		return PTR_ERR(vaddr);
 
 	iosys_map_set_vaddr(map, vaddr);
+#else
+	iosys_map_set_vaddr(map, bo->vaddr);
+#endif
 
 	return 0;
 }
 
 static void tegra_gem_prime_vunmap(struct dma_buf *buf, struct iosys_map *map)
 {
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 0, 0)
 	struct drm_gem_object *gem = buf->priv;
 	struct tegra_bo *bo = to_tegra_bo(gem);
 
 	tegra_bo_munmap(&bo->base, map->vaddr);
+#endif
 }
 #else
 static int tegra_gem_prime_vmap(struct dma_buf *buf, struct dma_buf_map *map)

drivers/gpu/drm/tegra/gr2d.c

@@ -8,9 +8,9 @@
 #include <linux/iommu.h>
 #include <linux/module.h>
 #include <linux/of_device.h>
-#include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/reset.h>
+#include <linux/version.h>
 
 #include <soc/tegra/common.h>
 
@@ -272,7 +272,7 @@ static int gr2d_probe(struct platform_device *pdev)
 	gr2d->client.version = gr2d->soc->version;
 	gr2d->client.ops = &gr2d_ops;
 
-#if defined(NV_DEVM_TEGRA_CORE_DEV_INIT_OPP_TABLE_COMMON_PRESENT) /* Linux v5.17 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0)
 	err = devm_tegra_core_dev_init_opp_table_common(dev);
 	if (err)
 		return err;

drivers/gpu/drm/tegra/gr3d.c

@@ -530,7 +530,7 @@ static int gr3d_probe(struct platform_device *pdev)
 	gr3d->client.version = gr3d->soc->version;
 	gr3d->client.ops = &gr3d_ops;
 
-#if defined(NV_DEVM_TEGRA_CORE_DEV_INIT_OPP_TABLE_COMMON_PRESENT) /* Linux v5.17 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0)
 	err = devm_tegra_core_dev_init_opp_table_common(&pdev->dev);
 	if (err)
 		return err;

drivers/gpu/drm/tegra/hdmi.c

@@ -4,8 +4,6 @@
  * Copyright (C) 2012 NVIDIA CORPORATION.  All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/debugfs.h>
 #include <linux/delay.h>
@@ -25,9 +23,6 @@
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_crtc.h>
 #include <drm/drm_debugfs.h>
-#if defined(NV_DRM_DRM_ELD_H_PRESENT)
-#include <drm/drm_eld.h>
-#endif
 #include <drm/drm_file.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_probe_helper.h>
@@ -1127,12 +1122,7 @@ static void tegra_hdmi_early_unregister(struct drm_connector *connector)
 	unsigned int count = ARRAY_SIZE(debugfs_files);
 	struct tegra_hdmi *hdmi = to_hdmi(output);
 
-#if defined(NV_DRM_DEBUGFS_REMOVE_FILES_HAS_ROOT_ARG) /* Linux v6.7 */
-	drm_debugfs_remove_files(hdmi->debugfs_files, count,
-				 connector->debugfs_entry, minor);
-#else
 	drm_debugfs_remove_files(hdmi->debugfs_files, count, minor);
-#endif
 	kfree(hdmi->debugfs_files);
 	hdmi->debugfs_files = NULL;
 }
@@ -1874,14 +1864,16 @@ static int tegra_hdmi_probe(struct platform_device *pdev)
 
 	platform_set_drvdata(pdev, hdmi);
 
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0)
 	err = devm_pm_runtime_enable(&pdev->dev);
 	if (err)
 		return err;
 
-#if defined(NV_DEVM_TEGRA_CORE_DEV_INIT_OPP_TABLE_COMMON_PRESENT) /* Linux v5.17 */
 	err = devm_tegra_core_dev_init_opp_table_common(&pdev->dev);
 	if (err)
 		return err;
+#else
+	pm_runtime_enable(&pdev->dev);
 #endif
 
 	INIT_LIST_HEAD(&hdmi->client.list);
@@ -1902,6 +1894,10 @@ static int tegra_hdmi_remove(struct platform_device *pdev)
 {
 	struct tegra_hdmi *hdmi = platform_get_drvdata(pdev);
 
+#if !(LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0))
+	pm_runtime_disable(&pdev->dev);
+#endif
+
 	host1x_client_unregister(&hdmi->client);
 
 	tegra_output_remove(&hdmi->output);

drivers/gpu/drm/tegra/hub.c

@@ -8,9 +8,9 @@
 #include <linux/dma-mapping.h>
 #include <linux/host1x-next.h>
 #include <linux/module.h>
+#include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_graph.h>
-#include <linux/of_platform.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 #include <linux/reset.h>

drivers/gpu/drm/tegra/nvdec.c

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2015-2024, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2015-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
  */
 
 #include <linux/bitops.h>
@@ -108,7 +108,7 @@ static int nvdec_set_rate(struct nvdec *nvdec, unsigned long rate)
 
 	if (nvdec->icc_write) {
 		emc_kbps = dev_rate * NVDEC_AXI_RW_BANDWIDTH / 1024;
-		err = icc_set_bw(nvdec->icc_write, 0, kbps_to_icc(emc_kbps));
+		err = icc_set_bw(nvdec->icc_write, kbps_to_icc(emc_kbps), 0);
 		if (err)
 			dev_warn(nvdec->dev, "failed to set icc bw: %d\n", err);
 	}
@@ -804,9 +804,10 @@ static int nvdec_probe(struct platform_device *pdev)
 	}
 
 	nvdec->icc_write = devm_of_icc_get(dev, "write");
-	if (IS_ERR(nvdec->icc_write))
-		return dev_err_probe(&pdev->dev, PTR_ERR(nvdec->icc_write),
-				     "failed to get icc write handle\n");
+	if (IS_ERR(nvdec->icc_write)) {
+		dev_err(&pdev->dev, "failed to get icc write handle\n");
+		return PTR_ERR(nvdec->icc_write);
+	}
 
 	platform_set_drvdata(pdev, nvdec);
 

drivers/gpu/drm/tegra/nvenc.c

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2024, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
  */
 
 #include <linux/bitops.h>
@@ -91,7 +91,7 @@ static int nvenc_set_rate(struct nvenc *nvenc, unsigned long rate)
 
 	if (nvenc->icc_write) {
 		emc_kbps = dev_rate * NVENC_AXI_RW_BANDWIDTH / 1024;
-		err = icc_set_bw(nvenc->icc_write, 0, kbps_to_icc(emc_kbps));
+		err = icc_set_bw(nvenc->icc_write, kbps_to_icc(emc_kbps), 0);
 		if (err)
 			dev_warn(nvenc->dev, "failed to set icc bw: %d\n", err);
 	}
@@ -670,9 +670,10 @@ static int nvenc_probe(struct platform_device *pdev)
 		return err;
 
 	nvenc->icc_write = devm_of_icc_get(dev, "write");
-	if (IS_ERR(nvenc->icc_write))
-		return dev_err_probe(&pdev->dev, PTR_ERR(nvenc->icc_write),
-				     "failed to get icc write handle\n");
+	if (IS_ERR(nvenc->icc_write)) {
+		dev_err(&pdev->dev, "failed to get icc write handle\n");
+		return PTR_ERR(nvenc->icc_write);
+	}
 
 	platform_set_drvdata(pdev, nvenc);
 

drivers/gpu/drm/tegra/nvjpg.c

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2024, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
  */
 
 #include <linux/bitops.h>
@@ -88,7 +88,7 @@ static int nvjpg_set_rate(struct nvjpg *nvjpg, unsigned long rate)
 
 	if (nvjpg->icc_write) {
 		emc_kbps = dev_rate * NVJPG_AXI_RW_BANDWIDTH / 1024;
-		err = icc_set_bw(nvjpg->icc_write, 0, kbps_to_icc(emc_kbps));
+		err = icc_set_bw(nvjpg->icc_write, kbps_to_icc(emc_kbps), 0);
 		if (err)
 			dev_warn(nvjpg->dev, "failed to set icc bw: %d\n", err);
 	}
@@ -655,9 +655,10 @@ static int nvjpg_probe(struct platform_device *pdev)
 		return err;
 
 	nvjpg->icc_write = devm_of_icc_get(dev, "write");
-	if (IS_ERR(nvjpg->icc_write))
-		return dev_err_probe(&pdev->dev, PTR_ERR(nvjpg->icc_write),
-				     "failed to get icc write handle\n");
+	if (IS_ERR(nvjpg->icc_write)) {
+		dev_err(&pdev->dev, "failed to get icc write handle\n");
+		return PTR_ERR(nvjpg->icc_write);
+	}
 
 	platform_set_drvdata(pdev, nvjpg);
 

drivers/gpu/drm/tegra/sor.c

@@ -32,9 +32,6 @@
 #endif
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_debugfs.h>
-#if defined(NV_DRM_DRM_ELD_H_PRESENT)
-#include <drm/drm_eld.h>
-#endif
 #include <drm/drm_file.h>
 #include <drm/drm_panel.h>
 #include <drm/drm_simple_kms_helper.h>
@@ -1721,15 +1718,8 @@ static void tegra_sor_early_unregister(struct drm_connector *connector)
 	unsigned int count = ARRAY_SIZE(debugfs_files);
 	struct tegra_sor *sor = to_sor(output);
 
-#if defined(NV_DRM_DEBUGFS_REMOVE_FILES_HAS_ROOT_ARG) /* Linux v6.7 */
-	drm_debugfs_remove_files(sor->debugfs_files, count,
-				 connector->debugfs_entry,
-				 connector->dev->primary);
-#else
-
 	drm_debugfs_remove_files(sor->debugfs_files, count,
 				 connector->dev->primary);
-#endif
 	kfree(sor->debugfs_files);
 	sor->debugfs_files = NULL;
 }

drivers/gpu/drm/tegra/vic.c

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * SPDX-FileCopyrightText: Copyright (C) 2015-2024 NVIDIA CORPORATION.  All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (C) 2015-2023 NVIDIA CORPORATION.  All rights reserved.
  */
 
 #include <linux/bitops.h>
@@ -129,7 +129,7 @@ static int vic_set_rate(struct vic *vic, unsigned long rate)
 
 	if (vic->icc_write) {
 		emc_kbps = dev_rate * VIC_AXI_RW_BANDWIDTH / 1024;
-		err = icc_set_bw(vic->icc_write, 0, kbps_to_icc(emc_kbps));
+		err = icc_set_bw(vic->icc_write, kbps_to_icc(emc_kbps), 0);
 		if (err)
 			dev_warn(vic->dev, "failed to set icc bw: %d\n", err);
 	}
@@ -723,9 +723,10 @@ static int vic_probe(struct platform_device *pdev)
 	}
 
 	vic->icc_write = devm_of_icc_get(dev, "write");
-	if (IS_ERR(vic->icc_write))
-		return dev_err_probe(&pdev->dev, PTR_ERR(vic->icc_write),
-				     "failed to get icc write handle\n");
+	if (IS_ERR(vic->icc_write)) {
+		dev_err(&pdev->dev, "failed to get icc write handle\n");
+		return PTR_ERR(vic->icc_write);
+	}
 
 	if (!dev->pm_domain) {
 		vic->rst = devm_reset_control_get(dev, "vic");

drivers/gpu/host1x-fence/dev.c

@@ -2,7 +2,7 @@
 /*
  * Host1x fence UAPI
  *
- * Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
  */
 
 #include <nvidia/conftest.h>
@@ -14,8 +14,7 @@
 #include <linux/host1x-next.h>
 #include <linux/module.h>
 #include <linux/of.h>
-#include <linux/of_platform.h>
-#include <linux/platform_device.h>
+#include <linux/of_device.h>
 #include <linux/poll.h>
 #include <linux/slab.h>
 #include <linux/sync_file.h>

drivers/gpu/host1x-nvhost/nvhost.c

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
+/*
+ * Copyright (c) 2022-2023, NVIDIA Corporation. All rights reserved.
+ */
 
 #include <nvidia/conftest.h>
 
@@ -543,6 +545,7 @@ int flcn_intr_init(struct platform_device *pdev)
 		return -ENXIO;
 	}
 
+	spin_lock_init(&pdata->mirq_lock);
 	ret = devm_request_irq(&pdev->dev, pdata->irq, flcn_isr, 0,
 			       dev_name(&pdev->dev), pdev);
 	if (ret) {

drivers/gpu/host1x/Makefile

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0-only
-# Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
 
-host1x-y = \
+host1x-next-y = \
 	bus.o \
 	syncpt.o \
 	dev.o \
@@ -21,7 +21,7 @@ host1x-y = \
 	hw/host1x07.o \
 	hw/host1x08.o
 
-host1x-$(CONFIG_IOMMU_API) += \
+host1x-next-$(CONFIG_IOMMU_API) += \
 	context.o
 
-obj-m := host1x.o
+obj-m := host1x-next.o

drivers/gpu/host1x/bus.c

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2013, NVIDIA Corporation
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/debugfs.h>
 #include <linux/dma-mapping.h>
 #include <linux/host1x-next.h>
@@ -13,6 +11,7 @@
 #include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/of_device.h>
+#include <linux/version.h>
 
 #include "bus.h"
 #include "dev.h"
@@ -340,7 +339,7 @@ static int host1x_device_match(struct device *dev, struct device_driver *drv)
 	return strcmp(dev_name(dev), drv->name) == 0;
 }
 
-#if defined(NV_BUS_TYPE_STRUCT_UEVENT_HAS_CONST_DEV_ARG) /* Linux v6.3 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0)
 static int host1x_device_uevent(const struct device *dev,
 #else
 static int host1x_device_uevent(struct device *dev,

drivers/gpu/host1x/cdma.c

@@ -496,7 +496,7 @@ resume:
 	host1x_hw_cdma_resume(host1x, cdma, restart_addr);
 }
 
-static void cdma_update_work(struct work_struct *work)
+void cdma_update_work(struct work_struct *work)
 {
 	struct host1x_cdma *cdma = container_of(work, struct host1x_cdma, update_work);
 

drivers/gpu/host1x/context.c

@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
- * Copyright (c) 2021-2024, NVIDIA Corporation.
+ * Copyright (c) 2021, NVIDIA Corporation.
  */
 
 #include <linux/device.h>
 #include <linux/kref.h>
 #include <linux/of.h>
-#include <linux/of_device.h>
+#include <linux/of_platform.h>
 #include <linux/pid.h>
 #include <linux/slab.h>
 

drivers/gpu/host1x/dev.c

@@ -5,18 +5,17 @@
  * Copyright (c) 2010-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
 #include <linux/io.h>
 #include <linux/list.h>
 #include <linux/module.h>
+#include <linux/of_device.h>
 #include <linux/of.h>
-#include <linux/of_platform.h>
 #include <linux/pm_runtime.h>
 #include <linux/slab.h>
+#include <linux/version.h>
 
 #include <soc/tegra/common.h>
 
@@ -951,7 +950,7 @@ static int host1x_probe(struct platform_device *pdev)
 
 	pm_runtime_enable(&pdev->dev);
 
-#if defined(NV_DEVM_TEGRA_CORE_DEV_INIT_OPP_TABLE_COMMON_PRESENT) /* Linux v5.17 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0)
 	err = devm_tegra_core_dev_init_opp_table_common(&pdev->dev);
 	if (err)
 		goto pm_disable;

drivers/hwmon/f75308.c

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// Copyright (c) 2023-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-
-#include <nvidia/conftest.h>
+// Copyright (c) 2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 #include <linux/hwmon-sysfs.h>
 #include <linux/hwmon.h>
@@ -1216,7 +1214,7 @@ destroy_lock:
 	return status;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 static int f75308_remove(struct i2c_client *client)
 #else
 static void f75308_remove(struct i2c_client *client)
@@ -1225,7 +1223,7 @@ static void f75308_remove(struct i2c_client *client)
 	struct f75308_priv *priv = dev_get_drvdata(&client->dev);
 
 	mutex_destroy(&priv->locker);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 	return 0;
 #endif
 }
@@ -1258,10 +1256,10 @@ static struct i2c_driver f75308_driver = {
 		.of_match_table = of_match_ptr(f75308_match_table),
 	},
 	.detect = f75308_detect,
-#if defined(NV_I2C_DRIVER_STRUCT_HAS_PROBE_NEW) /* Dropped on Linux 6.6 */
-	.probe_new = f75308_probe,
-#else
+#if defined(NV_I2C_LEGACY_PROBE_NEW_REMOVED)
 	.probe     = f75308_probe,
+#else
+	.probe_new = f75308_probe,
 #endif
 	.remove = f75308_remove,
 	.address_list = f75308_addr,

drivers/i2c/busses/i2c-nvvrs11.c

@@ -5,8 +5,6 @@
  * Copyright (C) 2022-2023 NVIDIA CORPORATION. All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -244,7 +242,7 @@ static int nvvrs11_vendor_info(struct nvvrs11_chip *chip)
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int nvvrs11_probe(struct i2c_client *client)
 #else
 static int nvvrs11_probe(struct i2c_client *client,
@@ -310,7 +308,7 @@ exit:
 	return ret;
 }
 
-#if !defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
 static void nvvrs11_remove(struct i2c_client *client)
 {
 	nvvrs11_delete_sys_files(&client->dev);

drivers/media/i2c/Makefile

@@ -1,5 +1,5 @@
 # SPDX-License-Identifier: GPL-2.0-only
-# Copyright (c) 2023-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 subdir-ccflags-y += -Werror
 
@@ -7,8 +7,6 @@ obj-m += max9295.o
 obj-m += max9296.o
 ifeq ($(findstring ack_src,$(NV_BUILD_KERNEL_OPTIONS)),)
 obj-m += max96712.o
-
-ifdef CONFIG_MEDIA_SUPPORT
 obj-m += ar1335_common.o
 obj-m += lt6911uxc.o
 obj-m += nv_imx185.o
@@ -19,9 +17,7 @@ obj-m += nv_imx390.o
 obj-m += nv_imx477.o
 obj-m += nv_ov5693.o
 obj-m += nv_ar0234.o
-obj-m += nv_hawk_owl.o
-endif
-
 obj-m += pca9570.o
+obj-m += nv_hawk_owl.o
 obj-m += virtual_i2c_mux.o
 endif

drivers/media/i2c/ar0234_mode_tbls.h

@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-/* Copyright (c) 2018-2024, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved. */
+/* Copyright (c) 2018-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved. */
 /*
  * ar0234_mode_tbls.h - ar0234 sensor mode tables
  */
@@ -62,6 +62,7 @@ static struct index_reg_8 ar0234_Double_Dser_Ser[] = {
 
 	{0x52, 0x0003, 0xAE}, // Disable CC to link B
 	{0x80, 0x0000, 0x84}, // Link A serializer address is 0x84
+
 	{0x52, 0x0003, 0xAB}, // Disable CC to link A
 	{0x80, 0x0000, 0x88}, // Link B serializer address is 0x88
 	{0x52, 0x0003, 0xAA}, // Enable CC to links A and B
@@ -69,17 +70,17 @@ static struct index_reg_8 ar0234_Double_Dser_Ser[] = {
 	{0x84, 0x0308, 0x7E}, // Pipe X pulls clock from port A, pipe Y from port B
 	{0x84, 0x0311, 0x21}, // Pipe X pulls data from port A, pipe Y from port B
 	{0x84, 0x0316, 0x6b}, // RAW10 to pipe Y
-	{0x84, 0x0314, 0x6b}, // RAW10 to pipe X
+	{0x84, 0x0314, 0x6b}, // RAW10 to pipe Y
 	{0x88, 0x0002, 0x33}, // Enable pipes X and Y
 	{0x88, 0x0308, 0x7E}, // Pipe X pulls clock from port A, pipe Y from port B
 	{0x88, 0x0311, 0x21}, // Pipe X pulls data from port A, pipe Y from port B
 	{0x88, 0x0316, 0x6b}, // RAW10 to pipe Y
-	{0x88, 0x0314, 0x6b}, // RAW10 to pipe X
-	{0x52, 0x00F4, 0x0f}, // Enable pipes 0-3 in deserializer
+	{0x88, 0x0314, 0x6b}, // RAW10 to pipe Y
+	{0x52, 0x00F4, 0x0f}, // Enable pipe 0
 	{0x52, 0x00F0, 0x10}, // Link A ID 0 to pipe 0 // Link A ID 1 to pipe 1
 	{0x52, 0x00F1, 0x54}, // Link B ID 0 to pipe 2  // Link B ID 1 to pipe 3
 
-	{0x52, 0x08A0, 0x01}, // CSI output is 4x2
+	{0x52, 0x08A0, 0x01}, // CSI output is 2x4
 	{0x52, 0x08A3, 0x44}, // Default 4x2 lane mapping
 	{0x52, 0x08A4, 0x44}, // Default 4x2 lane mapping
 
@@ -91,16 +92,16 @@ static struct index_reg_8 ar0234_Double_Dser_Ser[] = {
 	{0x52, 0x1D00, 0xF4},
 	{0x52, 0x1E00, 0xF4},
 
-	{0x52, 0x0415, 0x39},
-	{0x52, 0x0418, 0x39},	// Date rate is 2500Mbps/lane on port D
-	{0x52, 0x041B, 0x39},	// Data rate is 2500Mbps/lane on port E
-	{0x52, 0x041E, 0x39},
+	{0x52, 0x0415, 0x2E},
+	{0x52, 0x0418, 0x2E}, // 1400Mbps
+	{0x52, 0x041B, 0x2E},
+	{0x52, 0x041E, 0x2E},
 
 	{0x52, 0x1D00, 0xF5},
 	{0x52, 0x1E00, 0xF5},
 
 	{0x52, 0x090B, 0x07}, // Enable 3 mappings  Pipe 0//video2
-	{0x52, 0x092D, 0x00}, // All mappings to controller 0 (port C)
+	{0x52, 0x092D, 0x15}, // All mappings to controller 1 (port A)
 	{0x52, 0x090D, 0x2B}, // Input RAW10, VC0
 	{0x52, 0x090E, 0x2B}, // Output RAW10, VC0
 	{0x52, 0x090F, 0x00}, // Input FS, VC0
@@ -109,7 +110,7 @@ static struct index_reg_8 ar0234_Double_Dser_Ser[] = {
 	{0x52, 0x0912, 0x01}, // Output FE, VC0
 
 	{0x52, 0x094B, 0x07}, // Enable 3 mappings  Pipe 1  //video3
-	{0x52, 0x096D, 0x00}, // All mappings to controller 0 (port C)
+	{0x52, 0x096D, 0x15}, // All mappings to controller 1 (port A)
 	{0x52, 0x094D, 0x2B}, // Input RAW10, VC0
 	{0x52, 0x094E, 0x6B}, // Output RAW10, VC1
 	{0x52, 0x094F, 0x00}, // Input FS, VC0
@@ -118,23 +119,22 @@ static struct index_reg_8 ar0234_Double_Dser_Ser[] = {
 	{0x52, 0x0952, 0x41}, // Output FE, VC1
 
 	{0x52, 0x098B, 0x07}, // Enable 3 mappings Pipe 2  //video1
-	{0x52, 0x09AD, 0x15}, // All mappings to controller 1 (port D)
+	{0x52, 0x09AD, 0x15}, // All mappings to controller 1 (port A)
 	{0x52, 0x098D, 0x2B}, // Input RAW10, VC0
-	{0x52, 0x098E, 0x2B}, // Output RAW10, VC0
+	{0x52, 0x098E, 0xaB}, // Output RAW10, VC2
 	{0x52, 0x098F, 0x00}, // Input FS, VC0
-	{0x52, 0x0990, 0x00}, // Output FS, VC0
+	{0x52, 0x0990, 0x80}, // Output FS, VC2
 	{0x52, 0x0991, 0x01}, // Input FE, VC0
-	{0x52, 0x0992, 0x01}, // Output FE, VC0
+	{0x52, 0x0992, 0x81}, // Output FE, VC2
 
 	{0x52, 0x09CB, 0x07}, // Enable 3 mappings  Pipe 3  //video0
-	{0x52, 0x09ED, 0x15}, // All mappings to controller 1 (port D)
+	{0x52, 0x09ED, 0x15}, // All mappings to controller 1 (port A)
 	{0x52, 0x09CD, 0x2B}, // Input RAW10, VC0
-	{0x52, 0x09CE, 0x6B}, // Output RAW10, VC1
+	{0x52, 0x09CE, 0xeB}, // Output RAW10, VC3
 	{0x52, 0x09CF, 0x00}, // Input FS, VC0
-	{0x52, 0x09D0, 0x40}, // Output FS, VC1
+	{0x52, 0x09D0, 0xc0}, // Output FS, VC3
 	{0x52, 0x09D1, 0x01}, // Input FE, VC0
-	{0x52, 0x09D2, 0x41}, // Output FE, VC1
-
+	{0x52, 0x09D2, 0xc1}, // Output FE, VC3
 
 	{0x52, 0x08A2, 0xF0},
 	{0x84, 0x02be, 0x90}, // Enable sensor power down pin.

drivers/media/i2c/ar1335_common.c

@@ -1,12 +1,10 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2017-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// Copyright (c) 2017-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // Copyright (c) 2022, e-con Systems. All rights reserved.
 /*
- * ar1335_common.c - AR1335 sensor driver
+ * ar1335.c - AR1335 sensor driver
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -52,13 +50,11 @@ static uint32_t u8arr_to_uint32(uint8_t *in_arr)
 		in_arr[3]);
 }
 
-static int mcu_send_ctrl_cmd(struct i2c_client *client,
-			     int cmd,
-			     uint32_t payload_len,
-			     uint16_t index)
+static int mcu_send_ctrl_cmd(struct i2c_client *client, int cmd, uint32_t payload_len)
 {
 	int err;
 	uint8_t orig_crc = 0, calc_crc = 0;
+	uint16_t index = 0xFFFF;
 
 	mc_data[0] = CMD_SIGNATURE;
 	mc_data[1] = cmd;
@@ -413,7 +409,7 @@ static int cam_set_fmt(struct v4l2_subdev *sd, struct v4l2_subdev_state *cfg,
 			if ((priv->mcu_cam_frmfmt[ret].size.width ==
 				format->format.width) &&
 				(priv->mcu_cam_frmfmt[ret].size.height ==
-				format->format.height))
+				format->format.height)) 
 			{
 				priv->frmfmt_mode = priv->mcu_cam_frmfmt[ret].mode;
 				flag = 1;
@@ -988,7 +984,7 @@ static int mcu_get_ctrl(struct i2c_client *client, uint32_t arg_ctrl_id,
 
 	/* First Txn Payload length = 2 */
 	payload_len = 2;
-	ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_CTRL, payload_len, index);
+	ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_CTRL, payload_len);
 	if (ret) {
 		dev_err(&client->dev, "CMD_ID_GET_CTRL send failed\n");
 		goto exit;
@@ -1154,8 +1150,7 @@ static int mcu_list_fmts(struct i2c_client *client,ISP_STREAM_INFO *stream_info,
 		/* First Txn Payload length = 0 */
 		payload_len = 2;
 
-		ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_STREAM_INFO,
-					payload_len, index);
+		ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_STREAM_INFO, payload_len);
 		if (ret) {
 			dev_err(&client->dev, "CMD_ID_GET_STREAM_INFO send failed\n");
 			goto exit;
@@ -1277,8 +1272,7 @@ static int mcu_get_ctrl_ui(struct i2c_client *client,
 	/* First Txn Payload length = 0 */
 	payload_len = 2;
 
-	ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_CTRL_UI_INFO,
-				payload_len, index);
+	ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_CTRL_UI_INFO, payload_len);
 	if (ret) {
 		dev_err(&client->dev, "CMD_ID_GET_CTRL_UI_INFO send failed\n");
 		goto exit;
@@ -1408,8 +1402,7 @@ static int mcu_list_ctrls(struct i2c_client *client,
 		/* First Txn Payload length = 0 */
 		payload_len = 2;
 
-		ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_CTRL_INFO,
-					payload_len, index);
+		ret = mcu_send_ctrl_cmd(client, CMD_ID_GET_CTRL_INFO, payload_len);
 		if (ret) {
 			dev_err(&client->dev, "CMD_ID_GET_CTRL_INFO send failed\n");
 			goto exit;
@@ -2368,7 +2361,7 @@ exit:
 	return ret;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int cam_probe(struct i2c_client *client)
 #else
 static int cam_probe(struct i2c_client *client,
@@ -2790,7 +2783,7 @@ exit:
 		devm_kfree(dev, ptr); \
 	}
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int cam_remove(struct i2c_client *client)
 #else
 static void cam_remove(struct i2c_client *client)
@@ -2804,7 +2797,7 @@ static void cam_remove(struct i2c_client *client)
 
 	if (!s_data) {
 		dev_err(&client->dev, "camera common data is NULL\n");
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;
@@ -2816,7 +2809,7 @@ static void cam_remove(struct i2c_client *client)
 	reset_gpio = of_get_named_gpio(node, "reset-gpios", 0);
 	if (reset_gpio < 0) {
 		dev_err(&client->dev, "Unable to get reset GPIO\n");
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;

drivers/media/i2c/hawk_owl_mode_tbls.h

@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: GPL-2.0 */
-/* Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved. */
+/* Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved. */
 /*
  * hawk_owl_mode_tbls.h - ar0234 sensor mode tables
  */
@@ -179,9 +179,9 @@ static struct index_reg_8 i2c_address_trans_hawk1_eeprom[] = {
 };
 
 static struct index_reg_8 i2c_address_trans_hawk2_eeprom[] = {
-	{0x96, 0x0042, 0x2A},
+	{0x96, 0x0042, 0x84},
 	{0x96, 0x0043, 0xA8},
-	{0x96, 0x0044, 0x2C},
+	{0x96, 0x0044, 0x86},
 	{0x96, 0x0045, 0xAA},
 	{0x00, AR0234_TABLE_END, 0x00}
 };
@@ -530,7 +530,6 @@ static struct index_reg_8 ar0234_Hawk_TripleLink_Dser_Ser[] = {
 	{0x98, 0x0311, 0x21}, // Pipe X pulls data from port A, pipe Y from port B
 	{0x98, 0x0316, 0x6b}, // RAW10 to pipe Y
 	{0x98, 0x0314, 0x6b}, // RAW10 to pipe Y
-	{0x52, 0x00F4, 0x3f}, // Enable video pipe 0,1,2,3,4,5
 
 	/*Tuned params to fix streaming issues */
 	{0x52, 0x00F0, 0x10}, // Link A ID 0 to pipe 0 // Link A ID 1 to pipe 1

drivers/media/i2c/lt6911uxc.c

@@ -4,8 +4,6 @@
  * Lontium LT6911UXC HDMI-CSI bridge driver
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -669,7 +667,7 @@ static struct camera_common_sensor_ops lt6911uxc_common_ops = {
 };
 
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int lt6911uxc_probe(struct i2c_client *client)
 #else
 static int lt6911uxc_probe(struct i2c_client *client,
@@ -733,7 +731,7 @@ static int lt6911uxc_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int lt6911uxc_remove(struct i2c_client *client)
 #else
 static void lt6911uxc_remove(struct i2c_client *client)
@@ -743,7 +741,7 @@ static void lt6911uxc_remove(struct i2c_client *client)
 	struct lt6911uxc *priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;
@@ -753,7 +751,7 @@ static void lt6911uxc_remove(struct i2c_client *client)
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/max9295.c

@@ -4,8 +4,6 @@
  * max9295.c - max9295 GMSL Serializer driver
  */
 
-#include <nvidia/conftest.h>
-
 #include <media/camera_common.h>
 #include <linux/module.h>
 #include <media/max9295.h>
@@ -465,7 +463,7 @@ static  struct regmap_config max9295_regmap_config = {
 	.cache_type = REGCACHE_RBTREE,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int max9295_probe(struct i2c_client *client)
 #else
 static int max9295_probe(struct i2c_client *client,
@@ -514,7 +512,7 @@ static int max9295_probe(struct i2c_client *client,
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int max9295_remove(struct i2c_client *client)
 #else
 static void max9295_remove(struct i2c_client *client)
@@ -528,7 +526,7 @@ static void max9295_remove(struct i2c_client *client)
 		i2c_unregister_device(client);
 		client = NULL;
 	}
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/max9296.c

@@ -4,8 +4,6 @@
  * max9296.c - max9296 GMSL Deserializer driver
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/gpio.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -848,7 +846,7 @@ static struct regmap_config max9296_regmap_config = {
 	.cache_type = REGCACHE_RBTREE,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int max9296_probe(struct i2c_client *client)
 #else
 static int max9296_probe(struct i2c_client *client,
@@ -894,7 +892,7 @@ static int max9296_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int max9296_remove(struct i2c_client *client)
 #else
 static void max9296_remove(struct i2c_client *client)
@@ -908,7 +906,7 @@ static void max9296_remove(struct i2c_client *client)
 		i2c_unregister_device(client);
 		client = NULL;
 	}
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/max96712.c

@@ -7,8 +7,6 @@
 
 /* #define DEBUG */
 
-#include <nvidia/conftest.h>
-
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
 #include <media/camera_common.h>
@@ -228,7 +226,7 @@ static  struct regmap_config max96712_regmap_config = {
 	.cache_type = REGCACHE_RBTREE,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int max96712_probe(struct i2c_client *client)
 #else
 static int max96712_probe(struct i2c_client *client,
@@ -268,7 +266,7 @@ static int max96712_probe(struct i2c_client *client,
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int max96712_remove(struct i2c_client *client)
 #else
 static void max96712_remove(struct i2c_client *client)
@@ -279,7 +277,7 @@ static void max96712_remove(struct i2c_client *client)
 		i2c_unregister_device(client);
 		client = NULL;
 	}
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_ar0234.c

@@ -1,11 +1,9 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2018-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2018-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
 /*
  * ar0234.c - ar0234 sensor driver
  */
 
-#include <nvidia/conftest.h>
-
 #define DEBUG 1
 #include <linux/slab.h>
 #include <linux/uaccess.h>
@@ -28,7 +26,6 @@
 #define MAX_TANGENTIAL_COEFFICIENTS     2
 #define MAX_FISHEYE_COEFFICIENTS        6
 #define CAMERA_MAX_SN_LENGTH 32
-#define LEOP_CAMERA_MAX_SN_LENGTH 10
 #define MAX_RLS_COLOR_CHANNELS 4
 #define MAX_RLS_BREAKPOINTS 6
 
@@ -65,6 +62,7 @@ static const u32 ctrl_cid_list[] = {
 	TEGRA_CAMERA_CID_ALTERNATING_EXPOSURE,
 };
 
+const u16 alternating_exposure_cfg_size = sizeof(struct alternating_exposure_cfg);
 
 // Coefficients as per distortion model (wide FOV) being used
 struct fisheye_lens_distortion_coeff {
@@ -127,13 +125,7 @@ struct camera_extrinsics {
 	float tx, ty, tz;
 };
 
-/*
- * IMU parameters used by HAWK 1.0. HAWK 1.0 did not have IMU noise model parameters
- * in EEPROM. To preserve backward compatibility with HAWK 1.0, the EEPROM data is arranged
- * in a certain way which requires tracking the imu noise model parameters in a
- * separate structure.
- */
-struct imu_params_v1 {
+struct imu_params {
 	// 3D vector to add to accelerometer readings
 	float linear_acceleration_bias[3];
 	// 3D vector to add to gyroscope readings
@@ -142,12 +134,7 @@ struct imu_params_v1 {
 	float gravity_acceleration[3];
 	// Extrinsic structure for IMU device
 	struct camera_extrinsics extr;
-};
-
-struct imu_params_noise_m {
-	/*
-	 * Noise model parameters
-	 */
+	// Noise model parameters
 	float update_rate;
 	float linear_acceleration_noise_density;
 	float linear_acceleration_random_walk;
@@ -155,14 +142,6 @@ struct imu_params_noise_m {
 	float angular_velocity_random_walk;
 };
 
-/*
- * Combined IMU calibration data structure
- */
-struct imu_params_v2 {
-	struct imu_params_v1 imu_data_v1;
-	struct imu_params_noise_m nm;
-};
-
 struct radial_lsc_params {
 	// Image height
 	u16 image_height;
@@ -205,7 +184,7 @@ struct NvCamSyncSensorCalibData {
 	u8 imu_present;
 
 	// Intrinsic structure for IMU
-	struct imu_params_v2 imu;
+	struct imu_params imu;
 
 	// HAWK module serial number
 	u8 serial_number[CAMERA_MAX_SN_LENGTH];
@@ -240,14 +219,10 @@ struct LiEeprom_Content_Struct {
 	/**
 	 * Intrinsic structure for IMU
 	 */
-	struct imu_params_v1 imu;
-
-	u8 tmp[16];
+	struct imu_params imu;
 
 	// HAWK module serial number
-	u8 serial_number[LEOP_CAMERA_MAX_SN_LENGTH];
-
-	struct imu_params_noise_m nm;
+	u8 serial_number[CAMERA_MAX_SN_LENGTH];
 
 	// Radial Lens Shading Correction parameters
 	struct radial_lsc_params left_rls;
@@ -701,10 +676,9 @@ static int ar0234_fill_eeprom(struct tegracam_device *tc_dev,
 
 		priv->EepromCalib.cam_extr = tmp->cam_extr;
 		priv->EepromCalib.imu_present = tmp->imu_present;
-		priv->EepromCalib.imu.imu_data_v1 = tmp->imu;
-		priv->EepromCalib.imu.nm = tmp->nm;
+		priv->EepromCalib.imu = tmp->imu;
 		memcpy(priv->EepromCalib.serial_number, tmp->serial_number,
-			8);
+			CAMERA_MAX_SN_LENGTH);
 
 		if (priv->sync_sensor_index == 1)
 			priv->EepromCalib.rls = tmp->left_rls;
@@ -818,7 +792,7 @@ static struct tegracam_ctrl_ops ar0234_ctrl_ops = {
 	.numctrls = ARRAY_SIZE(ctrl_cid_list),
 	.ctrl_cid_list = ctrl_cid_list,
 	.string_ctrl_size = {AR0234_EEPROM_STR_SIZE},
-	.compound_ctrl_size = {sizeof(struct NvCamSyncSensorCalibData), sizeof(struct alternating_exposure_cfg)},
+	.compound_ctrl_size = {sizeof(struct NvCamSyncSensorCalibData), alternating_exposure_cfg_size},
 	.set_gain = ar0234_set_gain,
 	.set_exposure = ar0234_set_exposure,
 	.set_exposure_short = ar0234_set_exposure,
@@ -1070,7 +1044,7 @@ static int ar0234_board_setup(struct ar0234 *priv)
 
 
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int ar0234_probe(struct i2c_client *client)
 #else
 static int ar0234_probe(struct i2c_client *client,
@@ -1175,7 +1149,7 @@ static int ar0234_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int ar0234_remove(struct i2c_client *client)
 #else
 static void ar0234_remove(struct i2c_client *client)
@@ -1185,7 +1159,7 @@ static void ar0234_remove(struct i2c_client *client)
 	struct ar0234 *priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;
@@ -1195,7 +1169,7 @@ static void ar0234_remove(struct i2c_client *client)
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
 	ar0234_eeprom_device_release(priv);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_hawk_owl.c

@@ -1,11 +1,9 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2022-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All Rights Reserved.
 /*
  * nv_hawk_owl.c.c - ar0234 sensor driver
  */
 
-#include <nvidia/conftest.h>
-
 #define DEBUG 0
 #include <linux/slab.h>
 #include <linux/uaccess.h>
@@ -17,7 +15,6 @@
 #include <linux/of_gpio.h>
 #include <media/max9295.h>
 #include <media/max9296.h>
-#include <media/nv_hawk_owl.h>
 #include <media/tegracam_core.h>
 #include "hawk_owl_mode_tbls.h"
 #include <linux/ktime.h>
@@ -26,7 +23,6 @@
 #define MAX_TANGENTIAL_COEFFICIENTS     2
 #define MAX_FISHEYE_COEFFICIENTS        6
 #define CAMERA_MAX_SN_LENGTH            32
-#define LEOP_CAMERA_MAX_SN_LENGTH 	10
 #define MAX_RLS_COLOR_CHANNELS          4
 #define MAX_RLS_BREAKPOINTS             6
 #define OWL_CHANNEL			1
@@ -68,6 +64,8 @@ static const u32 ctrl_cid_list[] = {
 	TEGRA_CAMERA_CID_ALTERNATING_EXPOSURE,
 };
 
+const u16 alternating_exposure_cfg_size = sizeof(struct alternating_exposure_cfg);
+
 // Coefficients as per distortion model (wide FOV) being used
 typedef struct
 {
@@ -129,13 +127,6 @@ typedef struct
 	// Translation parameter from one camera to another parameter
 	float tx, ty, tz;
 } camera_extrinsics;
-
-/*
- * IMU parameters used by HAWK 1.0. HAWK 1.0 did not have IMU noise model parameters
- * in EEPROM. To preserve backward compatibility with HAWK 1.0, the EEPROM data is arranged
- * in a certain way which requires tracking the imu noise model parameters in a
- * separate structure.
- */
 typedef struct
 {
 	// 3D vector to add to accelerometer readings
@@ -146,26 +137,13 @@ typedef struct
 	float gravity_acceleration[3];
 	// Extrinsic structure for IMU device
 	camera_extrinsics extr;
-} imu_params_v1;
-
-typedef struct {
-	/*
-	 * Noise model parameters
-	 */
+	// Noise model parameters
 	float update_rate;
 	float linear_acceleration_noise_density;
 	float linear_acceleration_random_walk;
 	float angular_velocity_noise_density;
 	float angular_velocity_random_walk;
-} imu_params_noise_m;
-
-/*
- * Combined IMU calibration data structure
- */
-typedef struct {
-	imu_params_v1 imu_data_v1;
-	imu_params_noise_m nm;
-} imu_params_v2;
+} imu_params;
 
 typedef struct {
 	// Image height
@@ -209,7 +187,7 @@ typedef struct
 	u8 imu_present;
 
 	// Intrinsic structure for IMU
-	imu_params_v2 imu;
+	imu_params imu;
 
 	// HAWK module serial number
 	u8 serial_number[CAMERA_MAX_SN_LENGTH];
@@ -217,7 +195,6 @@ typedef struct
 	// Radial Lens Shading Correction parameters
 	radial_lsc_params rls;
 } NvCamSyncSensorCalibData;
-
 typedef struct
 {
 	/**
@@ -245,20 +222,15 @@ typedef struct
 	/**
 	 * Intrinsic structure for IMU
 	 */
-	imu_params_v1 imu;
-
-	u8 tmp[16];
+	imu_params imu;
 
 	// HAWK module serial number
-	u8 serial_number[LEOP_CAMERA_MAX_SN_LENGTH];
-
-	imu_params_noise_m nm;
+	u8 serial_number[CAMERA_MAX_SN_LENGTH];
 
 	// Radial Lens Shading Correction parameters
 	radial_lsc_params left_rls;
 	radial_lsc_params right_rls;
 } LiEeprom_Content_Struct;
-
 struct ar0234 {
 	struct camera_common_eeprom_data eeprom[AR0234_EEPROM_NUM_BLOCKS];
 	u8                              eeprom_buf[AR0234_EEPROM_SIZE];
@@ -273,20 +245,17 @@ struct ar0234 {
 	const char	*sensor_name;
 	NvCamSyncSensorCalibData EepromCalib;
 };
-
 static const struct regmap_config sensor_regmap_config = {
 	.reg_bits = 16,
 	.val_bits = 16,
 	.cache_type = REGCACHE_RBTREE,
 };
-
 static inline void ar0234_get_coarse_time_regs_shs1(ar0234_reg *regs,
 		u16 coarse_time)
 {
 	regs->addr = AR0234_COARSE_TIME_SHS1_ADDR;
 	regs->val = (coarse_time) & 0xffff;
 }
-
 static inline void ar0234_get_gain_reg(ar0234_reg *regs,
 		u16 gain)
 {
@@ -374,7 +343,7 @@ retry_sensor:
 				return -1;
 			} else {
 				if (0x301a == table[i].addr || 0x3060 == table[i].addr)
-					msleep(20);
+					msleep(100);
 			}
 		} else {
 			retry = 5;
@@ -585,7 +554,7 @@ static int ar0234_power_on(struct camera_common_data *s_data)
 	struct camera_common_power_rail *pw = s_data->power;
 	struct camera_common_pdata *pdata = s_data->pdata;
 	struct device *dev = s_data->dev;
-
+	struct ar0234 *priv = (struct ar0234 *) s_data->priv;
 	if (pdata && pdata->power_on) {
 		err = pdata->power_on(pw);
 		if (err)
@@ -598,6 +567,8 @@ static int ar0234_power_on(struct camera_common_data *s_data)
 		gpio_set_value(pw->reset_gpio, 1);
 	usleep_range(1000, 2000);
 	pw->state = SWITCH_ON;
+	/*i2c address trans for Hawk & Owl*/
+	err = ar0234_hawk_owl_i2ctrans(priv);
 	return err;
 }
 static int ar0234_power_off(struct camera_common_data *s_data)
@@ -792,10 +763,9 @@ static int ar0234_fill_eeprom(struct tegracam_device *tc_dev,
 			}
 			priv->EepromCalib.cam_extr = tmp->cam_extr;
 			priv->EepromCalib.imu_present = tmp->imu_present;
-			priv->EepromCalib.imu.imu_data_v1 = tmp->imu;
-			priv->EepromCalib.imu.nm = tmp->nm;
+			priv->EepromCalib.imu = tmp->imu;
 			memcpy(priv->EepromCalib.serial_number, tmp->serial_number,
-					8);
+					CAMERA_MAX_SN_LENGTH);
 
 			if (priv->sync_sensor_index == 1)
 				priv->EepromCalib.rls = tmp->left_rls;
@@ -907,7 +877,7 @@ static struct tegracam_ctrl_ops ar0234_ctrl_ops = {
 	.numctrls = ARRAY_SIZE(ctrl_cid_list),
 	.ctrl_cid_list = ctrl_cid_list,
 	.string_ctrl_size = {AR0234_EEPROM_STR_SIZE},
-	.compound_ctrl_size = {sizeof(NvCamSyncSensorCalibData), sizeof(struct alternating_exposure_cfg)},
+	.compound_ctrl_size = {sizeof(NvCamSyncSensorCalibData), alternating_exposure_cfg_size},
 	.set_gain = ar0234_set_gain,
 	.set_exposure = ar0234_set_exposure,
 	.set_exposure_short = ar0234_set_exposure,
@@ -1464,7 +1434,7 @@ static int ar0234_hawk_owl_deser_ser_program(struct ar0234 *priv)
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int ar0234_probe(struct i2c_client *client)
 #else
 static int ar0234_probe(struct i2c_client *client,
@@ -1533,14 +1503,6 @@ static int ar0234_probe(struct i2c_client *client,
 		dev_err(&client->dev,"Failed to enable gpio/ to do serializer i2c address trans\n");
 		goto un_register;
 	}
-
-	/* i2c address trans for Hawk & Owl */
-	err = ar0234_hawk_owl_i2ctrans(priv);
-	if (err) {
-		dev_err(&client->dev, "Failed to do i2c address trans\n");
-		goto un_register;
-	}
-
 	err = ar0234_power_on(tc_dev->s_data);
 	if (err) {
 		dev_err(&client->dev,"Failed to power on\n");
@@ -1610,7 +1572,7 @@ un_register:
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int ar0234_remove(struct i2c_client *client)
 #else
 static void ar0234_remove(struct i2c_client *client)
@@ -1620,7 +1582,7 @@ static void ar0234_remove(struct i2c_client *client)
 	struct ar0234 *priv = (struct ar0234 *)s_data->priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 	return;
@@ -1628,7 +1590,7 @@ static void ar0234_remove(struct i2c_client *client)
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
 	ar0234_eeprom_device_release(priv);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_imx185.c

@@ -5,8 +5,6 @@
  * Copyright (c) 2016-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -777,7 +775,7 @@ static const struct v4l2_subdev_internal_ops imx185_subdev_internal_ops = {
 	.open = imx185_open,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int imx185_probe(struct i2c_client *client)
 #else
 static int imx185_probe(struct i2c_client *client,
@@ -840,11 +838,11 @@ static int imx185_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
-static int
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
+static void
 imx185_remove(struct i2c_client *client)
 #else
-static void
+static int
 imx185_remove(struct i2c_client *client)
 #endif
 {
@@ -852,17 +850,17 @@ imx185_remove(struct i2c_client *client)
 	struct imx185 *priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
-		return -EINVAL;
-#else
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
 		return;
+#else
+		return -EINVAL;
 #endif
 
 	priv = (struct imx185 *)s_data->priv;
 
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_imx219.c

@@ -6,8 +6,6 @@
  *
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -693,7 +691,7 @@ static const struct v4l2_subdev_internal_ops imx219_subdev_internal_ops = {
 	.open = imx219_open,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int imx219_probe(struct i2c_client *client)
 #else
 static int imx219_probe(struct i2c_client *client,
@@ -756,10 +754,10 @@ static int imx219_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
-static int imx219_remove(struct i2c_client *client)
-#else
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
 static void imx219_remove(struct i2c_client *client)
+#else
+static int imx219_remove(struct i2c_client *client)
 #endif
 {
 	struct camera_common_data *s_data = to_camera_common_data(&client->dev);
@@ -767,7 +765,7 @@ static void imx219_remove(struct i2c_client *client)
 
 	if (!s_data) {
 		dev_err(&client->dev, "camera common data is NULL\n");
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 		return -EINVAL;
 #else
 		return;
@@ -778,7 +776,7 @@ static void imx219_remove(struct i2c_client *client)
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 	return 0;
 #endif
 }

drivers/media/i2c/nv_imx274.c

@@ -5,8 +5,6 @@
  * Copyright (c) 2015-2023, NVIDIA CORPORATION.  All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -1262,7 +1260,7 @@ static const struct v4l2_subdev_internal_ops imx274_subdev_internal_ops = {
 	.open = imx274_open,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int imx274_probe(struct i2c_client *client)
 #else
 static int imx274_probe(struct i2c_client *client,
@@ -1335,20 +1333,20 @@ static int imx274_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
-static int imx274_remove(struct i2c_client *client)
-#else
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
 static void imx274_remove(struct i2c_client *client)
+#else
+static int imx274_remove(struct i2c_client *client)
 #endif
 {
 	struct camera_common_data *s_data = to_camera_common_data(&client->dev);
 	struct imx274 *priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
-		return -EINVAL;
-#else
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
 		return;
+#else
+		return -EINVAL;
 #endif
 
 	priv = (struct imx274 *)s_data->priv;
@@ -1360,7 +1358,7 @@ static void imx274_remove(struct i2c_client *client)
 	imx274_eeprom_device_release(priv);
 
 	mutex_destroy(&priv->streaming_lock);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_imx318.c

@@ -1,11 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0
-// SPDX-FileCopyrightText: Copyright (c) 2017-2024 NVIDIA CORPORATION & AFFILIATES.
-// All rights reserved.
-//
-// nv_imx318.c - imx318 sensor driver
-//
-
-#include <nvidia/conftest.h>
+// Copyright (c) 2017-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 #include <linux/slab.h>
 #include <linux/uaccess.h>
@@ -135,11 +129,6 @@ static int imx318_set_frame_rate_ex(struct tegracam_device *tc_dev,
 	u8 fl_arr[2];
 	int err = 0;
 
-	if (val < mode->control_properties.min_framerate)
-		val = mode->control_properties.min_framerate;
-	else if (val > mode->control_properties.max_framerate)
-		val = mode->control_properties.max_framerate;
-
 	if (mode->image_properties.line_length == 0 ||
 	    val == 0) {
 		return -EINVAL;
@@ -706,7 +695,7 @@ static const struct v4l2_subdev_internal_ops imx318_subdev_internal_ops = {
 	.open = imx318_open,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int imx318_probe(struct i2c_client *client)
 #else
 static int imx318_probe(struct i2c_client *client,
@@ -770,7 +759,7 @@ static int imx318_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int imx318_remove(struct i2c_client *client)
 #else
 static void imx318_remove(struct i2c_client *client)
@@ -780,7 +769,7 @@ static void imx318_remove(struct i2c_client *client)
 	struct imx318 *priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;
@@ -791,7 +780,7 @@ static void imx318_remove(struct i2c_client *client)
 	tegracam_device_unregister(priv->tc_dev);
 	imx318_eeprom_device_release(priv);
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_imx390.c

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 // Copyright (c) 2018-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -754,7 +752,7 @@ error:
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int imx390_probe(struct i2c_client *client)
 #else
 static int imx390_probe(struct i2c_client *client,
@@ -856,7 +854,7 @@ static int imx390_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int imx390_remove(struct i2c_client *client)
 #else
 static void imx390_remove(struct i2c_client *client)
@@ -866,7 +864,7 @@ static void imx390_remove(struct i2c_client *client)
 	struct imx390 *priv;
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;
@@ -880,7 +878,7 @@ static void imx390_remove(struct i2c_client *client)
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_imx477.c

@@ -1,15 +1,13 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2021-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 /*
  * Copyright (c) 2020, RidgeRun. All rights reserved.
+ * Copyright (c) 2021-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  *
  * Contact us: support@ridgerun.com
  *
  * nv_imx477.c - imx477 sensor driver
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -26,8 +24,6 @@
 #include "../platform/tegra/camera/camera_gpio.h"
 #include "imx477_mode_tbls.h"
 
-#define IMX477_SENSOR_INTERNAL_CLK_FREQ   840000000
-
 static const struct of_device_id imx477_of_match[] = {
 	{.compatible = "ridgerun,imx477",},
 	{},
@@ -230,7 +226,7 @@ static int imx477_set_frame_rate(struct tegracam_device *tc_dev, s64 val)
 	if (val == 0 || mode->image_properties.line_length == 0)
 		return -EINVAL;
 
-	frame_length = (u32) (IMX477_SENSOR_INTERNAL_CLK_FREQ *
+	frame_length = (u32) (mode->signal_properties.pixel_clock.val *
 			      (u64) mode->control_properties.framerate_factor /
 			      mode->image_properties.line_length / val);
 
@@ -281,12 +277,12 @@ static int imx477_set_exposure(struct tegracam_device *tc_dev, s64 val)
 
 	fine_integ_time_factor = priv->fine_integ_time *
 		mode->control_properties.exposure_factor /
-		IMX477_SENSOR_INTERNAL_CLK_FREQ;
+		mode->signal_properties.pixel_clock.val;
 
 	dev_dbg(dev, "%s: Setting exposure control to: %lld\n", __func__, val);
 
 	coarse_time = (val - fine_integ_time_factor)
-	    * IMX477_SENSOR_INTERNAL_CLK_FREQ
+	    * mode->signal_properties.pixel_clock.val
 	    / mode->control_properties.exposure_factor
 	    / mode->image_properties.line_length;
 
@@ -724,7 +720,7 @@ static const struct v4l2_subdev_internal_ops imx477_subdev_internal_ops = {
 	.open = imx477_open,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int imx477_probe(struct i2c_client *client)
 #else
 static int imx477_probe(struct i2c_client *client,
@@ -784,10 +780,10 @@ static int imx477_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
-static int imx477_remove(struct i2c_client *client)
-#else
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0)
 static void imx477_remove(struct i2c_client *client)
+#else
+static int imx477_remove(struct i2c_client *client)
 #endif
 {
 	struct camera_common_data *s_data = to_camera_common_data(&client->dev);
@@ -795,7 +791,7 @@ static void imx477_remove(struct i2c_client *client)
 
 	if (!s_data) {
 		dev_err(&client->dev, "camera common data is NULL\n");
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 		return -EINVAL;
 #else
 		return;
@@ -805,7 +801,7 @@ static void imx477_remove(struct i2c_client *client)
 
 	tegracam_v4l2subdev_unregister(priv->tc_dev);
 	tegracam_device_unregister(priv->tc_dev);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 1, 0)
 	return 0;
 #endif
 }

drivers/media/i2c/nv_ov5693.c

@@ -6,8 +6,6 @@
  *
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/gpio.h>
@@ -1148,7 +1146,7 @@ static const struct v4l2_subdev_internal_ops ov5693_subdev_internal_ops = {
 	.open = ov5693_open,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int ov5693_probe(struct i2c_client *client)
 #else
 static int ov5693_probe(struct i2c_client *client,
@@ -1238,7 +1236,7 @@ fail:
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int
 ov5693_remove(struct i2c_client *client)
 #else
@@ -1250,7 +1248,7 @@ ov5693_remove(struct i2c_client *client)
 	struct camera_common_data *s_data = to_camera_common_data(&client->dev);
 
 	if (!s_data)
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 		return -EINVAL;
 #else
 		return;
@@ -1266,7 +1264,7 @@ ov5693_remove(struct i2c_client *client)
 	ov5693_eeprom_device_release(priv);
 
 	mutex_destroy(&priv->streaming_lock);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/i2c/pca9570.c

@@ -5,8 +5,6 @@
  * Copyright (c) 2016-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
 #include <linux/i2c.h>
@@ -260,7 +258,7 @@ static  struct regmap_config pca9570_regmap_config = {
 	.cache_type = REGCACHE_RBTREE,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int pca9570_probe(struct i2c_client *client)
 #else
 static int pca9570_probe(struct i2c_client *client,
@@ -310,7 +308,7 @@ static int pca9570_probe(struct i2c_client *client,
 	return err;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 static int pca9570_remove(struct i2c_client *client)
 #else
 static void pca9570_remove(struct i2c_client *client)
@@ -321,7 +319,7 @@ static void pca9570_remove(struct i2c_client *client)
 		client = NULL;
 	}
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 	return 0;
 #endif
 }

drivers/media/i2c/virtual_i2c_mux.c

@@ -4,8 +4,6 @@
  * virtual_i2c_mux.c - virtual i2c mux driver for P3762 & P3783 GMSL boards.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/i2c.h>
 #include <linux/i2c-mux.h>
 #include <linux/module.h>
@@ -49,7 +47,7 @@ static int virtual_i2c_mux_deselect(struct i2c_mux_core *muxc, u32 chan)
 	return ret;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int virtual_i2c_mux_probe(struct i2c_client *client)
 #else
 static int virtual_i2c_mux_probe(struct i2c_client *client,
@@ -106,7 +104,7 @@ err_parent:
 	return ret;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 static int virtual_i2c_mux_remove(struct i2c_client *client)
 #else
 static void virtual_i2c_mux_remove(struct i2c_client *client)
@@ -116,7 +114,7 @@ static void virtual_i2c_mux_remove(struct i2c_client *client)
 
 	i2c_mux_del_adapters(muxc);
 	i2c_put_adapter(muxc->parent);
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if (KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE)
 	return 0;
 #endif
 }

drivers/media/platform/tegra/Makefile

@@ -1,10 +1,8 @@
 # SPDX-License-Identifier: GPL-2.0-only
-# Copyright (c) 2022-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-ifdef CONFIG_MEDIA_SUPPORT
 obj-m += cdi/
-obj-m += tpg/
-endif
 obj-m += isc/
 obj-m += camera/
+obj-m += tpg/
 obj-m += cam_fsync/

drivers/media/platform/tegra/camera/Makefile

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: GPL-2.0-only
-# Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
 
-ifdef CONFIG_MEDIA_SUPPORT
 ifeq ($(findstring ack_src,$(NV_BUILD_KERNEL_OPTIONS)),)
 LINUXINCLUDE += -I$(srctree.nvidia-oot)/drivers/video/tegra/camera
 LINUXINCLUDE += -I$(srctree.nvidia-oot)/drivers/media/platform/tegra
@@ -33,4 +32,3 @@ tegra-camera-objs += fusa-capture/capture-isp.o
 obj-m += tegra-camera.o
 obj-m += tests/
 endif
-endif

drivers/media/platform/tegra/camera/csi/csi.c

@@ -2,11 +2,9 @@
 /*
  * NVIDIA Tegra CSI Device
  *
- * Copyright (c) 2015-2024, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2015-2022, NVIDIA CORPORATION.  All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/device.h>
 #include <linux/gpio/consumer.h>
@@ -687,9 +685,6 @@ static int tegra_csi_set_format(struct v4l2_subdev *subdev,
 }
 
 static int tegra_csi_g_frame_interval(struct v4l2_subdev *sd,
-#if defined(NV_V4L2_SUBDEV_PAD_OPS_STRUCT_HAS_GET_FRAME_INTERVAL)
-			struct v4l2_subdev_state *sd_state,
-#endif
 			struct v4l2_subdev_frame_interval *vfi)
 {
 	struct tegra_csi_channel *chan = to_csi_chan(sd);
@@ -721,15 +716,10 @@ static int tegra_csi_enum_mbus_code(struct v4l2_subdev *sd,
 static struct v4l2_subdev_video_ops tegra_csi_video_ops = {
 	.s_stream	= tegra_csi_s_stream,
 	.g_input_status = tegra_csi_g_input_status,
-#if !defined(NV_V4L2_SUBDEV_PAD_OPS_STRUCT_HAS_GET_FRAME_INTERVAL)
 	.g_frame_interval = tegra_csi_g_frame_interval,
-#endif
 };
 
 static struct v4l2_subdev_pad_ops tegra_csi_pad_ops = {
-#if defined(NV_V4L2_SUBDEV_PAD_OPS_STRUCT_HAS_GET_FRAME_INTERVAL)
-	.get_frame_interval = tegra_csi_g_frame_interval,
-#endif
 	.get_fmt	= tegra_csi_get_format,
 	.set_fmt	= tegra_csi_set_format,
 	.enum_mbus_code = tegra_csi_enum_mbus_code,

drivers/media/platform/tegra/camera/fusa-capture/capture-vi-channel.c

@@ -1,10 +1,10 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2017-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2017-2023 NVIDIA Corporation.  All rights reserved.
 
 /**
  * @file drivers/media/platform/tegra/camera/fusa-capture/capture-vi-channel.c
  *
- * @brief VI channel character device driver for the T234 Camera RTCPU
+ * @brief VI channel character device driver for the T186/T194 Camera RTCPU
  * platform.
  */
 
@@ -204,7 +204,11 @@ struct tegra_vi_channel *vi_channel_open_ex(
 		return ERR_PTR(-ENOMEM);
 
 	chan->drv = chan_drv;
-	chan->vi_capture_pdev = chan_drv->vi_capture_pdev;
+	if (chan_drv->use_legacy_path) {
+		chan->dev = chan_drv->dev;
+		chan->ndev = chan_drv->ndev;
+	} else
+		chan->vi_capture_pdev = chan_drv->vi_capture_pdev;
 
 	chan->ops = chan_drv->ops;
 
@@ -386,14 +390,17 @@ static long vi_channel_ioctl(
 		if (copy_from_user(&setup, ptr, sizeof(setup)))
 			break;
 
-		vi_get_nvhost_device(chan, &setup);
-		if (chan->dev == NULL) {
-			dev_err(&chan->vi_capture_pdev->dev,
-				"%s: channel device is NULL",
-				__func__);
-			return -EINVAL;
+		if (chan->drv->use_legacy_path == false) {
+			vi_get_nvhost_device(chan, &setup);
+			if (chan->dev == NULL) {
+				dev_err(&chan->vi_capture_pdev->dev,
+					"%s: channel device is NULL",
+					__func__);
+				return -EINVAL;
+			}
 		}
 
+
 		if (setup.request_size < sizeof(struct capture_descriptor)) {
 			dev_err(chan->dev,
 				"request size is too small to fit capture descriptor\n");
@@ -643,10 +650,16 @@ int vi_channel_drv_register(
 	if (unlikely(chan_drv == NULL))
 		return -ENOMEM;
 
-	chan_drv->dev = NULL;
-	chan_drv->ndev = NULL;
-	chan_drv->vi_capture_pdev = ndev;
-
+	if (strstr(ndev->name, "tegra-capture-vi") == NULL) {
+		chan_drv->use_legacy_path = true;
+		chan_drv->dev = &ndev->dev;
+		chan_drv->ndev = ndev;
+	} else {
+		chan_drv->use_legacy_path = false;
+		chan_drv->dev = NULL;
+		chan_drv->ndev = NULL;
+		chan_drv->vi_capture_pdev = ndev;
+	}
 	chan_drv->num_channels = max_vi_channels;
 	mutex_init(&chan_drv->lock);
 
@@ -663,7 +676,9 @@ int vi_channel_drv_register(
 	for (i = 0; i < chan_drv->num_channels; i++) {
 		dev_t devt = MKDEV(vi_channel_major, i);
 
-		struct device *dev = &chan_drv->vi_capture_pdev->dev;
+		struct device *dev =
+			(chan_drv->use_legacy_path)?chan_drv->dev :
+			&chan_drv->vi_capture_pdev->dev;
 		device_create(vi_channel_class, dev, devt, NULL,
 				"capture-vi-channel%u", i);
 	}
@@ -710,8 +725,7 @@ void vi_channel_drv_unregister(
 	mutex_lock(&chdrv_lock);
 	chan_drv = chdrv_;
 	chdrv_ = NULL;
-
-	WARN_ON(&chan_drv->vi_capture_pdev->dev != dev);
+	WARN_ON(chan_drv->dev != dev);
 	mutex_unlock(&chdrv_lock);
 
 	for (i = 0; i < chan_drv->num_channels; i++) {
@@ -720,7 +734,7 @@ void vi_channel_drv_unregister(
 		device_destroy(vi_channel_class, devt);
 	}
 
-	devm_kfree(&chan_drv->vi_capture_pdev->dev, chan_drv);
+	devm_kfree(chan_drv->dev, chan_drv);
 }
 EXPORT_SYMBOL(vi_channel_drv_unregister);
 

drivers/media/platform/tegra/camera/fusa-capture/capture-vi.c

@@ -1,10 +1,10 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2017-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2017-2023 NVIDIA Corporation.  All rights reserved.
 
 /**
  * @file drivers/media/platform/tegra/camera/fusa-capture/capture-vi.c
  *
- * @brief VI channel operations for the T234 Camera RTCPU platform.
+ * @brief VI channel operations for the T186/T194 Camera RTCPU platform.
  */
 
 #include <linux/completion.h>
@@ -448,7 +448,10 @@ int vi_capture_init(
 	struct platform_device *rtc_pdev;
 	struct device *dev;
 
-	dev = &chan->vi_capture_pdev->dev;
+	if (chan->drv->use_legacy_path)
+		dev = chan->dev;
+	else
+		dev = &chan->vi_capture_pdev->dev;
 
 	dev_dbg(dev, "%s++\n", __func__);
 	dn = of_find_node_by_path("tegra-camera-rtcpu");
@@ -592,7 +595,10 @@ int vi_capture_setup(
 	uint32_t vi_inst = 0;
 	struct device *dev;
 
-	dev = &chan->vi_capture_pdev->dev;
+	if (chan->drv->use_legacy_path)
+		dev = chan->dev;
+	else
+		dev = &chan->vi_capture_pdev->dev;
 
 	if (setup->csi_stream_id >= MAX_NVCSI_STREAM_IDS ||
 		setup->virtual_channel_id >= MAX_VIRTUAL_CHANNEL_PER_STREAM) {
@@ -1658,7 +1664,7 @@ static int capture_vi_probe(struct platform_device *pdev)
 
 	err = vi_channel_drv_register(pdev, info->max_vi_channels);
 	if (err) {
-		vi_channel_drv_exit();
+		vi_channel_drv_exit();	
 		goto cleanup;
 	}
 
@@ -1696,10 +1702,7 @@ static int capture_vi_remove(struct platform_device *pdev)
 	for (ii = 0; ii < info->num_vi_devices; ii++)
 		put_device(&info->vi_pdevices[ii]->dev);
 
-	vi_channel_drv_unregister(&pdev->dev);
-	tegra_vi_media_controller_cleanup(&info->vi_common.mc_vi);
-	vi_channel_drv_exit();
-
+	vi_channel_drv_exit();	
 	return 0;
 }
 

drivers/media/platform/tegra/camera/tegracam_ctrls.c

@@ -2,7 +2,7 @@
 /*
  * tegracam_ctrls - control framework for tegra camera drivers
  *
- * Copyright (c) 2017-2023, NVIDIA CORPORATION.  All rights reserved.
+ * Copyright (c) 2017-2022, NVIDIA CORPORATION.  All rights reserved.
  */
 
 #include <linux/nospec.h>

drivers/media/platform/tegra/camera/vi/channel.c

@@ -1,7 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2015-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
 /*
  * NVIDIA Tegra Video Input Device
+ *
+ * Copyright (c) 2015-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
 
 #include <linux/atomic.h>
@@ -1022,21 +1023,14 @@ static int
 tegra_channel_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
 {
 	struct tegra_channel *chan = video_drvdata(file);
-	ssize_t len;
 	int ret = 0;
 
 	cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
 	cap->device_caps |= V4L2_CAP_EXT_PIX_FORMAT;
 	cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 
-	len = strscpy(cap->driver, "tegra-video", sizeof(cap->driver));
-	if (len < 0)
-		return -ENAMETOOLONG;
-
-	len = strscpy(cap->card, chan->video->name, sizeof(cap->card));
-	if (len < 0)
-		return -ENAMETOOLONG;
-
+	strlcpy(cap->driver, "tegra-video", sizeof(cap->driver));
+	strlcpy(cap->card, chan->video->name, sizeof(cap->card));
 	ret = snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s:%u",
 		 dev_name(chan->vi->dev), chan->port[0]);
 	if (ret < 0)

drivers/media/platform/tegra/camera/vi/graph.c

@@ -2,11 +2,8 @@
 /*
  * NVIDIA Media controller graph management
  *
- * Copyright (c) 2015-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * Copyright (c) 2015-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
-
-#include <nvidia/conftest.h>
-
 #include <linux/clk.h>
 #include <linux/list.h>
 #include <linux/of.h>
@@ -16,6 +13,7 @@
 #include <linux/regulator/consumer.h>
 #include <linux/reset.h>
 #include <linux/slab.h>
+#include <linux/version.h>
 #include <soc/tegra/fuse.h>
 #include <media/media-device.h>
 #include <media/v4l2-async.h>
@@ -343,7 +341,7 @@ register_device_error:
 	return ret;
 }
 
-#if defined(NV_V4L2_ASYNC_CONNECTION_STRUCT_PRESENT) /* Linux 6.5 */
+#if defined(NV_V4L2_ASYNC_SUBDEV_RENAME)
 static int tegra_vi_graph_notify_bound(struct v4l2_async_notifier *notifier,
 				   struct v4l2_subdev *subdev,
 				   struct v4l2_async_connection *asd)
@@ -382,7 +380,7 @@ static int tegra_vi_graph_notify_bound(struct v4l2_async_notifier *notifier,
 	return -EINVAL;
 }
 
-#if defined(NV_V4L2_ASYNC_CONNECTION_STRUCT_PRESENT) /* Linux 6.5 */
+#if defined(NV_V4L2_ASYNC_SUBDEV_RENAME)
 static void tegra_vi_graph_notify_unbind(struct v4l2_async_notifier *notifier,
 				   struct v4l2_subdev *subdev,
 				   struct v4l2_async_connection *asd)
@@ -425,7 +423,7 @@ void tegra_vi_graph_cleanup(struct tegra_mc_vi *vi)
 
 	list_for_each_entry(chan, &vi->vi_chans, list) {
 #if defined(CONFIG_V4L2_ASYNC)
-#if defined(NV_V4L2_ASYNC_NOTIFIER_INIT_PRESENT)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 16, 0)
 		v4l2_async_notifier_unregister(&chan->notifier);
 #else
 		v4l2_async_nf_unregister(&chan->notifier);
@@ -479,14 +477,12 @@ static int tegra_vi_graph_parse_one(struct tegra_channel *chan,
 		}
 
 		entity->node = remote;
-#if !defined(NV_V4L2_ASYNC_CONNECTION_STRUCT_PRESENT) /* Linux 6.5 */
-#if defined(NV_V4L2_ASYNC_MATCH_TYPE_ENUM_PRESENT) /* Linux 6.5 */
+#if defined(NV_V4L2_ASYNC_MATCH_FWNODE_RENAME)
 		entity->asd.match.type = V4L2_ASYNC_MATCH_TYPE_FWNODE;
 #else
 		entity->asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
 #endif
 		entity->asd.match.fwnode = of_fwnode_handle(remote);
-#endif
 
 		list_add_tail(&entity->list, &chan->entities);
 		chan->num_subdevs++;
@@ -642,14 +638,12 @@ int tegra_vi_graph_init(struct tegra_mc_vi *vi)
 
 		/* Add the remote entity of this endpoint */
 		entity->node = remote;
-#if !defined(NV_V4L2_ASYNC_CONNECTION_STRUCT_PRESENT) /* Linux 6.5 */
-#if defined(NV_V4L2_ASYNC_MATCH_TYPE_ENUM_PRESENT) /* Linux 6.5 */
+#if defined(NV_V4L2_ASYNC_MATCH_FWNODE_RENAME)
 		entity->asd.match.type = V4L2_ASYNC_MATCH_TYPE_FWNODE;
 #else
 		entity->asd.match_type = V4L2_ASYNC_MATCH_FWNODE;
 #endif
 		entity->asd.match.fwnode = of_fwnode_handle(remote);
-#endif
 		list_add_tail(&entity->list, &chan->entities);
 		chan->num_subdevs++;
 		chan->notifier.ops = chan->notifier.ops ? chan->notifier.ops : &vi_chan_notify_ops;
@@ -670,44 +664,39 @@ int tegra_vi_graph_init(struct tegra_mc_vi *vi)
 
 		i = 0;
 #if defined(CONFIG_V4L2_ASYNC)
-#if defined(NV_V4L2_ASYNC_NOTIFIER_INIT_PRESENT)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 16, 0)
 		v4l2_async_notifier_init(&chan->notifier);
 		list_for_each_entry(entity, &chan->entities, list)
 			__v4l2_async_notifier_add_subdev(&chan->notifier, &entity->asd);
 #else
-#if defined(NV_V4L2_ASYNC_NF_INIT_HAS_V4L2_DEV_ARG) /* Linux 6.6 */
-		v4l2_async_nf_init(&chan->notifier, &vi->v4l2_dev);
+#if defined (NV_V4L2_ASYNC_NF_SUBDEVICE_INIT_RENAME)
+		v4l2_async_subdev_nf_init(&chan->notifier, tegra_channel_find_linked_csi_subdev(chan));
+		list_for_each_entry(entity, &chan->entities, list) {
+			struct v4l2_async_connection *asd;
+			asd = v4l2_async_nf_add_fwnode_remote(&chan->notifier, of_fwnode_handle(remote),
+				struct v4l2_async_connection);
+			if (IS_ERR(asd)) {
+				ret = PTR_ERR(asd);
+				goto done;
+			}
+		}
 #else
 		v4l2_async_nf_init(&chan->notifier);
-#endif
-
-#if defined(NV_V4L2_ASYNC_NF_ADD_SUBDEV_PRESENT) /* Linux 6.6 */
 		list_for_each_entry(entity, &chan->entities, list)
 			__v4l2_async_nf_add_subdev(&chan->notifier, &entity->asd);
-#else
-		list_for_each_entry(entity, &chan->entities, list) {
-			struct v4l2_async_connection *asc;
-			asc = v4l2_async_nf_add_fwnode(&chan->notifier, of_fwnode_handle(entity->node),
-					struct v4l2_async_connection);
-			if (IS_ERR(asc))
-				asc = NULL;
-			entity->asc = asc;
-		}
-#endif /* NV_V4L2_ASYNC_NF_ADD_SUBDEV_PRESENT */
-#endif /* NV_V4L2_ASYNC_NOTIFIER_INIT_PRESENT */
+#endif
+#endif
 
 		chan->link_status = 0;
 		chan->subdevs_bound = 0;
 
 		/* Register the async notifier for this channel */
-#if defined(NV_V4L2_ASYNC_NOTIFIER_INIT_PRESENT)
+#if LINUX_VERSION_CODE < KERNEL_VERSION(5, 16, 0)
 		ret = v4l2_async_notifier_register(&vi->v4l2_dev,
 					&chan->notifier);
 #else
-#if defined (NV_V4L2_ASYNC_NF_INIT_HAS_V4L2_DEV_ARG) /* Linux 6.6 */
+#if defined (NV_V4L2_ASYNC_NF_SUBDEVICE_INIT_RENAME)
 		ret = v4l2_async_nf_register(&chan->notifier);
-		if (ret < 0)
-			v4l2_async_nf_cleanup(&chan->notifier);
 #else
 		ret = v4l2_async_nf_register(&vi->v4l2_dev,
 					&chan->notifier);
@@ -716,9 +705,9 @@ int tegra_vi_graph_init(struct tegra_mc_vi *vi)
 #else
 		dev_err(vi->dev, "CONFIG_V4L2_ASYNC is not enabled!\n");
 		ret = -ENOTSUPP;
-#endif /* CONFIG_V4L2_ASYNC */
+#endif
 		if (ret < 0) {
-			dev_err(vi->dev, "notifier registration failed %d\n", ret);
+			dev_err(vi->dev, "notifier registration failed\n");
 			goto done;
 		}
 

drivers/media/platform/tegra/camera/vi/mc_common.c

@@ -1,7 +1,8 @@
-// SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (c) 2015-2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: GPL-2.0
 /*
  * Tegra Video Input device common APIs
+ *
+ * Copyright (c) 2015-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
 
 #include <linux/init.h>
@@ -115,15 +116,11 @@ static void tegra_vi_notify(struct v4l2_subdev *sd,
 
 int tegra_vi_v4l2_init(struct tegra_mc_vi *vi)
 {
-	ssize_t len;
 	int ret;
 
 	vi->media_dev.dev = vi->dev;
-	len = strscpy(vi->media_dev.model, "NVIDIA Tegra Video Input Device",
+	strlcpy(vi->media_dev.model, "NVIDIA Tegra Video Input Device",
 		sizeof(vi->media_dev.model));
-	if (len < 0)
-		return -ENAMETOOLONG;
-
 	vi->media_dev.hw_revision = 3;
 
 	media_device_init(&vi->media_dev);

drivers/media/platform/tegra/camera/vi/vi5_fops.c

@@ -2,7 +2,7 @@
 /*
  * Tegra Video Input 5 device common APIs
  *
- * Copyright (c) 2016-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * Copyright (c) 2016-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  */
 
 #include <linux/errno.h>
@@ -319,8 +319,6 @@ static int tegra_channel_capture_setup(struct tegra_channel *chan, unsigned int
 	chan->request[vi_port] = dma_alloc_coherent(chan->tegra_vi_channel[vi_port]->rtcpu_dev,
 					setup.queue_depth * setup.request_size,
 					&setup.iova, GFP_KERNEL);
-	chan->request_iova[vi_port] = setup.iova;
-
 	if (chan->request[vi_port] == NULL) {
 		dev_err(chan->vi->dev, "dma_alloc_coherent failed\n");
 		return -ENOMEM;
@@ -969,24 +967,6 @@ static int vi5_channel_stop_streaming(struct vb2_queue *vq)
 				dev_err(&chan->video->dev,
 					"vi capture release failed\n");
 
-			/* Release capture requests */
-			if (chan->request[vi_port] != NULL) {
-				dma_free_coherent(chan->tegra_vi_channel[vi_port]->rtcpu_dev,
-				chan->capture_queue_depth * sizeof(struct capture_descriptor),
-				chan->request[vi_port], chan->request_iova[vi_port]);
-			}
-			chan->request[vi_port] = NULL;
-
-			/* Release emd data buffers */
-			if (chan->emb_buf_size > 0) {
-				struct device *vi_unit_dev;
-				vi5_unit_get_device_handle(chan->vi->ndev, chan->port[0],\
-										&vi_unit_dev);
-				dma_free_coherent(vi_unit_dev, chan->emb_buf_size,
-								chan->emb_buf_addr, chan->emb_buf);
-				chan->emb_buf_size = 0;
-			}
-
 			vi_channel_close_ex(chan->vi_channel_id[vi_port],
 						chan->tegra_vi_channel[vi_port]);
 			chan->tegra_vi_channel[vi_port] = NULL;
@@ -994,7 +974,6 @@ static int vi5_channel_stop_streaming(struct vb2_queue *vq)
 
 		/* release all remaining buffers to v4l2 */
 		tegra_channel_queued_buf_done(chan, VB2_BUF_STATE_ERROR, false);
-
 	}
 
 	return 0;

drivers/media/platform/tegra/cdi/Makefile

@@ -1,8 +1,10 @@
 # SPDX-License-Identifier: GPL-2.0-only
 # Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
+ifneq ($(CONFIG_TEGRA_GPIO_LEGACY_DISABLE),y)
 obj-m	+= cdi_gpio.o
 obj-m	+= cdi_mgr.o
+endif
 obj-m	+= cdi_dev.o
 obj-m	+= cdi_pwm.o
 ifeq ($(findstring ack_src,$(NV_BUILD_KERNEL_OPTIONS)),)

drivers/media/platform/tegra/cdi/cdi_dev.c

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 // Copyright (c) 2015-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-#include <nvidia/conftest.h>
-
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/fs.h>
@@ -566,7 +564,7 @@ static void cdi_dev_get_cim_ver(struct device_node *np, struct cdi_dev_info *inf
 	}
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int cdi_dev_probe(struct i2c_client *client)
 #else
 static int cdi_dev_probe(struct i2c_client *client,
@@ -807,7 +805,7 @@ static int cdi_dev_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 static int cdi_dev_remove(struct i2c_client *client)
 #else
 static void cdi_dev_remove(struct i2c_client *client)
@@ -828,7 +826,7 @@ static void cdi_dev_remove(struct i2c_client *client)
 	if (info->cdev.dev)
 		cdev_del(&info->cdev);
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 	return 0;
 #endif
 }

drivers/media/platform/tegra/cdi/cdi_gpio.c

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 // Copyright (c) 2017-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-#include <nvidia/conftest.h>
-
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -42,9 +40,6 @@ static struct gpio_chip *cdi_gpio_get_chip(struct platform_device *pdev,
 						struct cdi_gpio_plat_data *pd)
 {
 	struct gpio_chip *gc = NULL;
-#if !defined(NV_GPIOCHIP_FIND_PRESENT) /* Linux 6.7 */
-	struct gpio_device *gdev;
-#endif
 	char name[MAX_STR_SIZE];
 
 	if (strlen(pd->gpio_prnt_chip) > MAX_STR_SIZE) {
@@ -54,15 +49,7 @@ static struct gpio_chip *cdi_gpio_get_chip(struct platform_device *pdev,
 	}
 	strcpy(name, pd->gpio_prnt_chip);
 
-#if defined(NV_GPIOCHIP_FIND_PRESENT) /* Linux 6.7 */
 	gc = gpiochip_find(name, cdi_gpio_chip_match);
-#else
-	gdev = gpio_device_find(name, cdi_gpio_chip_match);
-	if (gdev) {
-		gc = gpio_device_get_chip(gdev);
-		gpio_device_put(gdev);
-	}
-#endif
 	if (!gc) {
 		dev_err(&pdev->dev, "%s: unable to find gpio parent chip %s\n",
 			__func__, pd->gpio_prnt_chip);
@@ -288,10 +275,7 @@ static int cdi_gpio_probe(struct platform_device *pdev)
 	gc->base = -1;
 	gc->ngpio = pd->max_gpio;
 	gc->label = "cdi-gpio";
-	gc->parent = &pdev->dev;
-#if defined(NV_GPIO_CHIP_STRUCT_HAS_OF_NODE_PRESENT) /* Linux 6.2 */
 	gc->of_node = pdev->dev.of_node;
-#endif
 	gc->owner = THIS_MODULE;
 
 	err = gpiochip_add_data(gc, cdi_gpio);

drivers/media/platform/tegra/cdi/cdi_mgr.c

@@ -14,7 +14,6 @@
 #include <linux/platform_device.h>
 #include <linux/device.h>
 #include <linux/of_irq.h>
-#include <linux/of.h>
 #include <linux/interrupt.h>
 #include <asm/siginfo.h>
 #include <linux/rcupdate.h>
@@ -31,6 +30,7 @@
 #include <media/cdi-mgr.h>
 #include <linux/gpio/consumer.h>
 #include <linux/semaphore.h>
+#include <linux/version.h>
 
 #include <asm/barrier.h>
 
@@ -1328,23 +1328,15 @@ static int cdi_mgr_of_get_grp_gpio(
 	struct device *dev, struct device_node *np,
 	const char *name, int size, u32 *grp, u32 *flags)
 {
-	char prop_name[32]; /* 32 is max size of property name */
 	int num, i;
 
-	snprintf(prop_name, sizeof(prop_name), "%s-gpios", name);
-
-	num = gpiod_count(dev, name);
-	dev_dbg(dev, "    num gpios of %s: %d\n", prop_name, num);
+	num = of_gpio_named_count(np, name);
+	dev_dbg(dev, "    num gpios of %s: %d\n", name, num);
 	if (num < 0)
 		return 0;
 
 	for (i = 0; (i < num) && (i < size); i++) {
-#if defined(NV_OF_GET_NAMED_GPIO_FLAGS_PRESENT) /* Linux 6.2 */
-		grp[i] = of_get_named_gpio_flags(np, prop_name, i, &flags[i]);
-#else
-		grp[i] = of_get_named_gpio(np, prop_name, i);
-		flags[i] = 0;
-#endif
+		grp[i] = of_get_named_gpio_flags(np, name, i, &flags[i]);
 		if ((int)grp[i] < 0) {
 			dev_err(dev, "%s: gpio[%d] invalid\n", __func__, i);
 			return -EINVAL;
@@ -1454,13 +1446,13 @@ static struct cdi_mgr_platform_data *of_cdi_mgr_pdata(struct platform_device
 	dev_dbg(&pdev->dev, "    csiport: %d\n", pd->csi_port);
 
 	pd->num_pwr_gpios = cdi_mgr_of_get_grp_gpio(
-		&pdev->dev, child_np, "pwdn",
+		&pdev->dev, child_np, "pwdn-gpios",
 		ARRAY_SIZE(pd->pwr_gpios), pd->pwr_gpios, pd->pwr_flags);
 	if (pd->num_pwr_gpios < 0)
 		return ERR_PTR(pd->num_pwr_gpios);
 
 	pd->num_mcdi_gpios = cdi_mgr_of_get_grp_gpio(
-		&pdev->dev, child_np, "mcdi",
+		&pdev->dev, child_np, "mcdi-gpios",
 		ARRAY_SIZE(pd->mcdi_gpios), pd->mcdi_gpios, pd->mcdi_flags);
 	if (pd->num_mcdi_gpios < 0)
 		return ERR_PTR(pd->num_mcdi_gpios);
@@ -1496,10 +1488,10 @@ static struct cdi_mgr_platform_data *of_cdi_mgr_pdata(struct platform_device
 	return pd;
 }
 
-#if defined(NV_CLASS_STRUCT_DEVNODE_HAS_CONST_DEV_ARG) /* Linux v6.2 */
-static char *cdi_mgr_devnode(const struct device *dev, umode_t *mode)
-#else
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 2, 0)
 static char *cdi_mgr_devnode(struct device *dev, umode_t *mode)
+#else
+static char *cdi_mgr_devnode(const struct device *dev, umode_t *mode)
 #endif
 {
 	if (!mode)
@@ -1660,8 +1652,13 @@ static int cdi_mgr_configure_gpios(struct device *dev, struct cdi_mgr_priv *cdi_
 					}
 				}
 
+#if LINUX_VERSION_CODE < KERNEL_VERSION(6, 2, 0)
+				cdi_mgr->gpios[i].desc = devm_fwnode_get_gpiod_from_child(dev,
+					"devblk", &child->fwnode, GPIOD_ASIS, NULL);
+#else
 				cdi_mgr->gpios[i].desc = devm_fwnode_gpiod_get_index(dev,
 					&child->fwnode, "devblk", 0, GPIOD_ASIS, NULL);
+#endif
 				if (IS_ERR(cdi_mgr->gpios[i].desc)) {
 					ret = PTR_ERR(cdi_mgr->gpios[i].desc);
 					if (ret < 0)

drivers/media/platform/tegra/cdi/cdi_pwm.c

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0
-// Copyright (c) 2016-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-
-#include <nvidia/conftest.h>
+// Copyright (c) 2016-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 #include <linux/module.h>
 #include <linux/of.h>
@@ -132,9 +130,7 @@ static const struct pwm_ops cdi_pwm_ops = {
 	.enable = cdi_pwm_enable,
 	.disable = cdi_pwm_disable,
 #endif
-#if defined(NV_PWM_OPS_STRUCT_HAS_OWNER) /* Linux 6.7 */
 	.owner = THIS_MODULE,
-#endif
 };
 
 static int cdi_pwm_probe(struct platform_device *pdev)
@@ -163,11 +159,10 @@ static int cdi_pwm_probe(struct platform_device *pdev)
 
 	info->chip.dev = &pdev->dev;
 	info->chip.ops = &cdi_pwm_ops;
-#if defined(NV_PWM_CHIP_STRUCT_HAS_BASE_ARG)
 	info->chip.base = -1;
-#endif
 	info->chip.npwm = npwm;
 	info->chip.of_xlate = of_cdi_pwm_xlate;
+	info->chip.of_pwm_n_cells = 2;
 	info->force_on = force_on;
 
 	err = pwmchip_add(&info->chip);

drivers/media/platform/tegra/isc/Makefile

@@ -3,7 +3,12 @@
 
 GCOV_PROFILE := y
 
+LINUX_VERSION := $(shell expr $(VERSION) \* 256 + $(PATCHLEVEL))
+LINUX_VERSION_6_3 := $(shell expr 6 \* 256 + 3)
+
+ifneq ($(CONFIG_TEGRA_GPIO_LEGACY_DISABLE),y)
 obj-m	+= isc_gpio.o
 obj-m	+= isc_mgr.o
+endif
 obj-m	+= isc_dev.o
 obj-m	+= isc_pwm.o

drivers/media/platform/tegra/isc/isc_dev.c

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 // Copyright (c) 2015-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-#include <nvidia/conftest.h>
-
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/fs.h>
@@ -429,7 +427,7 @@ static const struct file_operations isc_dev_fileops = {
 	.release = isc_dev_release,
 };
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int isc_dev_probe(struct i2c_client *client)
 #else
 static int isc_dev_probe(struct i2c_client *client,
@@ -514,7 +512,7 @@ static int isc_dev_probe(struct i2c_client *client,
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 static int isc_dev_remove(struct i2c_client *client)
 #else
 static void isc_dev_remove(struct i2c_client *client)
@@ -535,7 +533,7 @@ static void isc_dev_remove(struct i2c_client *client)
 	if (info->cdev.dev)
 		cdev_del(&info->cdev);
 
-#if defined(NV_I2C_DRIVER_STRUCT_REMOVE_RETURN_TYPE_INT) /* Linux 6.1 */
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
 	return 0;
 #endif
 }

drivers/media/platform/tegra/isc/isc_gpio.c

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 // Copyright (c) 2017-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-#include <nvidia/conftest.h>
-
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/of.h>
@@ -43,9 +41,6 @@ static struct gpio_chip *isc_gpio_get_chip(struct platform_device *pdev,
 {
 	struct gpio_chip *gc = NULL;
 	char name[MAX_STR_SIZE];
-#if !defined(NV_GPIOCHIP_FIND_PRESENT) /* Linux 6.7 */
-	struct gpio_device *gdev;
-#endif
 
 	if (strlen(pd->gpio_prnt_chip) > MAX_STR_SIZE) {
 		dev_err(&pdev->dev, "%s: gpio chip name is too long: %s\n",
@@ -54,15 +49,7 @@ static struct gpio_chip *isc_gpio_get_chip(struct platform_device *pdev,
 	}
 	strcpy(name, pd->gpio_prnt_chip);
 
-#if defined(NV_GPIOCHIP_FIND_PRESENT) /* Linux 6.7 */
 	gc = gpiochip_find(name, isc_gpio_chip_match);
-#else
-	gdev = gpio_device_find(name, isc_gpio_chip_match);
-	if (gdev) {
-		gc = gpio_device_get_chip(gdev);
-		gpio_device_put(gdev);
-	}
-#endif
 	if (!gc) {
 		dev_err(&pdev->dev, "%s: unable to find gpio parent chip %s\n",
 			__func__, pd->gpio_prnt_chip);
@@ -288,10 +275,7 @@ static int isc_gpio_probe(struct platform_device *pdev)
 	gc->base = -1;
 	gc->ngpio = pd->max_gpio;
 	gc->label = "isc-gpio";
-	gc->parent = &pdev->dev;
-#if defined(NV_GPIO_CHIP_STRUCT_HAS_OF_NODE_PRESENT) /* Linux 6.2 */
 	gc->of_node = pdev->dev.of_node;
-#endif
 	gc->owner = THIS_MODULE;
 
 	err = gpiochip_add_data(gc, isc_gpio);

drivers/media/platform/tegra/isc/isc_mgr.c

@@ -9,7 +9,6 @@
 #include <linux/slab.h>
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
-#include <linux/of.h>
 #include <linux/regmap.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
@@ -19,6 +18,7 @@
 #include <asm/siginfo.h>
 #include <linux/rcupdate.h>
 #include <linux/sched.h>
+#include <linux/version.h>
 #include <linux/sched/signal.h>
 #include <linux/uaccess.h>
 #include <linux/atomic.h>
@@ -813,23 +813,15 @@ static int isc_mgr_of_get_grp_gpio(
 	struct device *dev, struct device_node *np,
 	const char *name, int size, u32 *grp, u32 *flags)
 {
-	char prop_name[32]; /* 32 is max size of property name */
 	int num, i;
 
-	snprintf(prop_name, sizeof(prop_name), "%s-gpios", name);
-
-	num = gpiod_count(dev, name);
-	dev_dbg(dev, "    num gpios of %s: %d\n", prop_name, num);
+	num = of_gpio_named_count(np, name);
+	dev_dbg(dev, "    num gpios of %s: %d\n", name, num);
 	if (num < 0)
 		return 0;
 
 	for (i = 0; (i < num) && (i < size); i++) {
-#if defined(NV_OF_GET_NAMED_GPIO_FLAGS_PRESENT) /* Linux 6.2 */
-		grp[i] = of_get_named_gpio_flags(np, prop_name, i, &flags[i]);
-#else
-		grp[i] = of_get_named_gpio(np, prop_name, i);
-		flags[i] = 0;
-#endif
+		grp[i] = of_get_named_gpio_flags(np, name, i, &flags[i]);
 		if ((int)grp[i] < 0) {
 			dev_err(dev, "%s: gpio[%d] invalid\n", __func__, i);
 			return -EINVAL;
@@ -932,13 +924,13 @@ static struct isc_mgr_platform_data *of_isc_mgr_pdata(struct platform_device
 	dev_dbg(&pdev->dev, "    csiport: %d\n", pd->csi_port);
 
 	pd->num_pwr_gpios = isc_mgr_of_get_grp_gpio(
-		&pdev->dev, np, "pwdn",
+		&pdev->dev, np, "pwdn-gpios",
 		ARRAY_SIZE(pd->pwr_gpios), pd->pwr_gpios, pd->pwr_flags);
 	if (pd->num_pwr_gpios < 0)
 		return ERR_PTR(pd->num_pwr_gpios);
 
 	pd->num_misc_gpios = isc_mgr_of_get_grp_gpio(
-		&pdev->dev, np, "misc",
+		&pdev->dev, np, "misc-gpios",
 		ARRAY_SIZE(pd->misc_gpios), pd->misc_gpios, pd->misc_flags);
 	if (pd->num_misc_gpios < 0)
 		return ERR_PTR(pd->num_misc_gpios);
@@ -965,10 +957,10 @@ static struct isc_mgr_platform_data *of_isc_mgr_pdata(struct platform_device
 	return pd;
 }
 
-#if defined(NV_CLASS_STRUCT_DEVNODE_HAS_CONST_DEV_ARG) /* Linux v6.2 */
-static char *isc_mgr_devnode(const struct device *dev, umode_t *mode)
-#else
+#if (LINUX_VERSION_CODE < KERNEL_VERSION(6, 2, 0))
 static char *isc_mgr_devnode(struct device *dev, umode_t *mode)
+#else
+static char *isc_mgr_devnode(const struct device *dev, umode_t *mode)
 #endif
 {
 	if (!mode)

drivers/media/platform/tegra/isc/isc_pwm.c

@@ -1,7 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0
-// Copyright (c) 2016-2024, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-
-#include <nvidia/conftest.h>
+// Copyright (c) 2016-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 #include <linux/module.h>
 #include <linux/of.h>
@@ -132,9 +130,7 @@ static const struct pwm_ops isc_pwm_ops = {
 	.enable = isc_pwm_enable,
 	.disable = isc_pwm_disable,
 #endif
-#if defined(NV_PWM_OPS_STRUCT_HAS_OWNER) /* Linux 6.7 */
 	.owner = THIS_MODULE,
-#endif
 };
 
 static int isc_pwm_probe(struct platform_device *pdev)
@@ -163,11 +159,10 @@ static int isc_pwm_probe(struct platform_device *pdev)
 
 	info->chip.dev = &pdev->dev;
 	info->chip.ops = &isc_pwm_ops;
-#if defined(NV_PWM_CHIP_STRUCT_HAS_BASE_ARG)
 	info->chip.base = -1;
-#endif
 	info->chip.npwm = npwm;
 	info->chip.of_xlate = of_isc_pwm_xlate;
+	info->chip.of_pwm_n_cells = 2;
 	info->force_on = force_on;
 
 	err = pwmchip_add(&info->chip);

drivers/mfd/max77851.c

@@ -4,8 +4,6 @@
  * Maxim MAX77851 MFD Driver
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/mfd/core.h>
@@ -16,6 +14,7 @@
 #include <linux/of_device.h>
 #include <linux/regmap.h>
 #include <linux/slab.h>
+#include <linux/version.h>
 
 #define IS_MX_MASTER23(fps) ((fps == MX_FPS_MASTER2) || (fps == MX_FPS_MASTER3))
 #define IS_MX_MASTER01(fps) ((fps == MX_FPS_MASTER0) || (fps == MX_FPS_MASTER1))
@@ -504,7 +503,7 @@ static void max77851_pm_power_off(void)
 			   FPS_SW_COLD_RST, FPS_SW_COLD_RST);
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(6, 3, 0)
 static int max77851_probe(struct i2c_client *client)
 #else
 static int max77851_probe(struct i2c_client *client,

drivers/mfd/nvidia-vrs-pseq.c

@@ -5,8 +5,6 @@
  * Copyright (C) 2020-2023 NVIDIA CORPORATION. All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/i2c.h>
 #include <linux/interrupt.h>
 #include <linux/mfd/core.h>
@@ -18,6 +16,7 @@
 #include <linux/regmap.h>
 #include <linux/slab.h>
 #include <linux/err.h>
+#include <linux/version.h>
 
 static const struct resource rtc_resources[] = {
 	DEFINE_RES_IRQ(NVVRS_PSEQ_INT_SRC1_RTC),
@@ -186,7 +185,7 @@ static int nvvrs_pseq_vendor_info(struct nvvrs_pseq_chip *chip)
 	return 0;
 }
 
-#if defined(NV_I2C_DRIVER_STRUCT_PROBE_WITHOUT_I2C_DEVICE_ID_ARG) /* Linux 6.3 */
+#if KERNEL_VERSION(6, 3, 0) <= LINUX_VERSION_CODE
 static int nvvrs_pseq_probe(struct i2c_client *client)
 #else
 static int nvvrs_pseq_probe(struct i2c_client *client,

drivers/misc/Makefile

@@ -1,13 +1,17 @@
 # SPDX-License-Identifier: GPL-2.0
-# Copyright (c) 2022-2024, NVIDIA CORPORATION.  All rights reserved.
+# Copyright (c) 2022-2023, NVIDIA CORPORATION.  All rights reserved.
 
 ifeq ($(findstring ack_src,$(NV_BUILD_KERNEL_OPTIONS)),)
+ifneq ($(CONFIG_TEGRA_IVC_LEGACY_DISABLE),y)
 obj-m += mods/
 endif
+endif
 obj-m += nvsciipc/
 ifdef CONFIG_PCI
 obj-m += tegra-pcie-dma-test.o
 endif
+ifneq ($(CONFIG_TEGRA_GPIO_LEGACY_DISABLE),y)
 obj-m += bluedroid_pm.o
+endif
 obj-m += nvscic2c-pcie/
 obj-m += ioctl_example.o

drivers/misc/bluedroid_pm.c

@@ -1,9 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-// SPDX-FileCopyrightText: Copyright (C) 2019-2023 NVIDIA CORPORATION.  All rights reserved.
-
-#include <nvidia/conftest.h>
-
-#include <nvidia/conftest.h>
+/* Copyright (c) 2019-2022, NVIDIA CORPORATION & AFFILIATES. All rights reserved */
 
 #include <linux/uaccess.h>
 #include <linux/module.h>
@@ -17,6 +13,7 @@
 #include <linux/delay.h>
 #include <linux/timer.h>
 #include <linux/of_gpio.h>
+#include <linux/version.h>
 #include "bluedroid_pm.h"
 
 #define PROC_DIR	"bluetooth/sleep"
@@ -212,7 +209,7 @@ static ssize_t lpm_read_proc(struct file *file, char __user *buf, size_t size,
 					loff_t *ppos)
 {
 	char msg[50];
-#if defined(NV_PDE_DATA_LOWER_CASE_PRESENT) /* Linux v5.17 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0)
 	struct bluedroid_pm_data *bluedroid_pm = pde_data(file_inode(file));
 #else
 	struct bluedroid_pm_data *bluedroid_pm = PDE_DATA(file_inode(file));
@@ -228,7 +225,7 @@ static ssize_t lpm_write_proc(struct file *file, const char __user *buffer,
 					size_t count, loff_t *ppos)
 {
 	char *buf;
-#if defined(NV_PDE_DATA_LOWER_CASE_PRESENT) /* Linux v5.17 */
+#if LINUX_VERSION_CODE >= KERNEL_VERSION(5, 17, 0)
 	struct bluedroid_pm_data *bluedroid_pm = pde_data(file_inode(file));
 #else
 	struct bluedroid_pm_data *bluedroid_pm = PDE_DATA(file_inode(file));
@@ -344,9 +341,7 @@ static int bluedroid_pm_probe(struct platform_device *pdev)
 	int ret;
 	bool enable = false;  /* off */
 	struct device_node *node;
-#if defined(NV_OF_GET_NAMED_GPIO_FLAGS_PRESENT) /* Linux 6.2 */
 	enum of_gpio_flags of_flags;
-#endif
 	unsigned long flags;
 
 	bluedroid_pm = devm_kzalloc(&pdev->dev, sizeof(*bluedroid_pm), GFP_KERNEL);
@@ -370,14 +365,9 @@ static int bluedroid_pm_probe(struct platform_device *pdev)
 		}
 	}
 
-#if defined(NV_OF_GET_NAMED_GPIO_FLAGS_PRESENT) /* Linux 6.2 */
 	bluedroid_pm->gpio_reset =
 		of_get_named_gpio_flags(node, "bluedroid_pm,reset-gpio",
 								 0, &of_flags);
-#else
-	bluedroid_pm->gpio_reset =
-		of_get_named_gpio(node, "bluedroid_pm,reset-gpio", 0);
-#endif
 	bluedroid_pm->gpio_shutdown =
 		of_get_named_gpio(node, "bluedroid_pm,shutdown-gpio", 0);
 	bluedroid_pm->host_wake =
@@ -390,11 +380,7 @@ static int bluedroid_pm_probe(struct platform_device *pdev)
 			     &bluedroid_pm->resume_min_frequency);
 
 	if (gpio_is_valid(bluedroid_pm->gpio_reset)) {
-#if defined(NV_OF_GET_NAMED_GPIO_FLAGS_PRESENT) /* Linux 6.2 */
 		flags = (of_flags == OF_GPIO_ACTIVE_LOW) ? GPIOF_ACTIVE_LOW : 0;
-#else
-		flags = 0;
-#endif
 		ret = gpio_request_one(bluedroid_pm->gpio_reset, flags,
 								 "reset_gpio");
 		if (ret) {

drivers/misc/mods/mods_dma.c

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-/* SPDX-FileCopyrightText: Copyright (c) 2017-2024, NVIDIA CORPORATION.  All rights reserved. */
+/* SPDX-FileCopyrightText: Copyright (c) 2017-2023, NVIDIA CORPORATION.  All rights reserved. */
 
 #include <linux/device.h>
 #include <linux/dmaengine.h>
@@ -279,6 +279,9 @@ int esc_mods_dma_set_config(struct mods_client *client,
 	config.src_maxburst = p_config->src_maxburst;
 	config.dst_maxburst = p_config->dst_maxburst;
 	config.device_fc = (p_config->device_fc == 0) ? false : true;
+#if KERNEL_VERSION(5, 17, 0) > MODS_KERNEL_VERSION
+	config.slave_id = p_config->slave_id;
+#endif
 
 	cl_debug(DEBUG_TEGRADMA,
 		"ch: %d dir [%d], addr[%p -> %p], burst [%d %d] width [%d %d]\n",
@@ -288,6 +291,12 @@ int esc_mods_dma_set_config(struct mods_client *client,
 		config.src_maxburst, config.dst_maxburst,
 		config.src_addr_width, config.dst_addr_width);
 
+#if KERNEL_VERSION(5, 17, 0) > MODS_KERNEL_VERSION
+	cl_debug(DEBUG_TEGRADMA,
+		"slave id %d\n",
+		config.slave_id);
+#endif
+
 	write_lock(&(p_mods_chan->lock));
 	err = dmaengine_slave_config(p_mods_chan->pch, &config);
 	write_unlock(&(p_mods_chan->lock));

drivers/misc/mods/mods_internal.h

@@ -670,7 +670,7 @@ int esc_mods_send_trustzone_msg(struct mods_client         *client,
 	struct MODS_TZ_PARAMS      *p);
 #endif
 
-#if IS_ENABLED(CONFIG_OPTEE)
+#ifdef CONFIG_OPTEE
 /* OP-TEE TA call */
 int esc_mods_invoke_optee_ta(struct mods_client *client,
 	struct MODS_OPTEE_PARAMS *p);

drivers/misc/mods/mods_irq.c

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-/* SPDX-FileCopyrightText: Copyright (c) 2008-2024, NVIDIA CORPORATION.  All rights reserved. */
+/* SPDX-FileCopyrightText: Copyright (c) 2008-2023, NVIDIA CORPORATION.  All rights reserved. */
 
 #include "mods_internal.h"
 
@@ -8,10 +8,11 @@
 #include <linux/interrupt.h>
 #include <linux/pci_regs.h>
 #if defined(MODS_HAS_TEGRA) && defined(CONFIG_OF) && defined(CONFIG_OF_IRQ)
+#include <linux/of.h>
 #include <linux/of_irq.h>
 #include <linux/io.h>
 #include <linux/platform_device.h>
-#include <linux/of_platform.h>
+#include <linux/of_device.h>
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
 #endif

drivers/misc/mods/mods_smmu_drv.c

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: GPL-2.0-only
-/* SPDX-FileCopyrightText: Copyright (c) 2019-2024, NVIDIA CORPORATION.  All rights reserved. */
+/* SPDX-FileCopyrightText: Copyright (c) 2019-2023, NVIDIA CORPORATION.  All rights reserved. */
 
 #include <linux/kernel.h>
 #include <linux/device.h>
@@ -12,8 +12,8 @@
 #include <linux/version.h>
 #include <linux/dma-buf.h>
 
+#include <linux/of.h>
 #include <linux/of_platform.h>
-#include <linux/platform_device.h>
 #include <linux/acpi.h>
 #include "mods_internal.h"
 

drivers/misc/nvscic2c-pcie/endpoint.c

@@ -17,6 +17,7 @@
 #include <linux/printk.h>
 #include <linux/slab.h>
 #include <linux/types.h>
+#include <linux/version.h>
 #include <linux/wait.h>
 
 #include <uapi/misc/nvscic2c-pcie-ioctl.h>
@@ -344,7 +345,7 @@ endpoint_fops_mmap(struct file *filp, struct vm_area_struct *vma)
 	}
 
 	vma->vm_pgoff  = 0;
-#if defined(NV_VM_AREA_STRUCT_HAS_CONST_VM_FLAGS) /* Linux v6.3 */
+#if defined(CONFIG_TEGRA_SYSTEM_TYPE_ACK) && (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0))
 	vm_flags_set(vma, VM_DONTCOPY);
 #else
 	vma->vm_flags |= (VM_DONTCOPY); // fork() not supported.

drivers/misc/nvscic2c-pcie/epc/module.c

@@ -1,8 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0-only
 // Copyright (c) 2022-2023, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
-#include <nvidia/conftest.h>
-
 #define pr_fmt(fmt)	"nvscic2c-pcie: epc: " fmt
 
 #include <linux/aer.h>
@@ -292,9 +290,7 @@ deinit:
 
 	pci_release_region(pdev, 0);
 	pci_clear_master(pdev);
-#if defined(NV_PCI_DISABLE_PCIE_ERROR_REPORTING_PRESENT) /* Linux 6.5 */
 	pci_disable_pcie_error_reporting(pdev);
-#endif
 	pci_disable_device(pdev);
 
 	dt_release(&drv_ctx->drv_param);
@@ -354,7 +350,7 @@ nvscic2c_pcie_epc_probe(struct pci_dev *pdev,
 	ret = pcim_enable_device(pdev);
 	if (ret)
 		goto err_enable_device;
-#if defined(NV_PCI_ENABLE_PCIE_ERROR_REPORTING_PRESENT) /* Linux 6.5 */
+#if !defined(NV_DROP_PCIE_ERROR_REPORTING)
 	pci_enable_pcie_error_reporting(pdev);
 #endif
 	pci_set_master(pdev);

drivers/misc/nvscic2c-pcie/epf/module.c

@@ -733,11 +733,7 @@ static const struct pci_epc_event_ops nvscic2c_event_ops = {
 };
 
 static int
-#if defined(NV_PCI_EPF_DRIVER_STRUCT_PROBE_HAS_ID_ARG) /* Linux 6.4 */
-nvscic2c_pcie_epf_probe(struct pci_epf *epf, const struct pci_epf_device_id *id)
-#else
 nvscic2c_pcie_epf_probe(struct pci_epf *epf)
-#endif
 {
 	int ret = 0;
 	char *name = NULL;

drivers/misc/nvscic2c-pcie/stream-extensions.c

@@ -3,8 +3,6 @@
 
 #define pr_fmt(fmt)	"nvscic2c-pcie: stream-ext: " fmt
 
-#include <nvidia/conftest.h>
-
 #include <linux/anon_inodes.h>
 #include <linux/device.h>
 #include <linux/errno.h>
@@ -17,6 +15,7 @@
 #include <linux/slab.h>
 #include <linux/syscalls.h>
 #include <linux/tegra-pcie-edma.h>
+#include <linux/version.h>
 
 #include <uapi/misc/nvscic2c-pcie-ioctl.h>
 
@@ -295,7 +294,7 @@ fops_mmap(struct file *filep, struct vm_area_struct *vma)
 	memaddr = stream_obj->aper;
 
 	vma->vm_pgoff  = 0;
-#if defined(NV_VM_AREA_STRUCT_HAS_CONST_VM_FLAGS) /* Linux v6.3 */
+#if defined(CONFIG_TEGRA_SYSTEM_TYPE_ACK) && (LINUX_VERSION_CODE >= KERNEL_VERSION(6, 1, 0))
 	vm_flags_set(vma, VM_DONTCOPY);
 #else
 	vma->vm_flags |= (VM_DONTCOPY);

drivers/misc/nvsciipc/README

@@ -19,7 +19,7 @@ make -C /lib/modules/`uname -r`/build M=${PWD} modules
 sudo make -C /lib/modules/`uname -r`/build M=${PWD} modules_install
 sudo depmod -a
 
-nvsciipc.ko will be installed in /lib/modules/`uname -r`/updates/nvsciipc.ko
+nvsciipc.ko will be installed in /lib/modules/`uname -r`/extra/nvsciipc.ko
 
 [NOTE] If kernel module installation is failed by missing signing key, follow steps below
 

drivers/misc/nvsciipc/nvsciipc.c

@@ -1,6 +1,13 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * SPDX-FileCopyrightText: Copyright (c) 2019-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ *
+ * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
+ * property and proprietary rights in and to this material, related
+ * documentation and any modifications thereto. Any use, reproduction,
+ * disclosure or distribution of this material and related documentation
+ * without an express license agreement from NVIDIA CORPORATION or
+ * its affiliates is strictly prohibited.
  */
 
 /*

drivers/misc/tegra-pcie-dma-test.c

@@ -5,8 +5,6 @@
  * Copyright (C) 2021-2023 NVIDIA Corporation. All rights reserved.
  */
 
-#include <nvidia/conftest.h>
-
 #include <linux/aer.h>
 #include <linux/delay.h>
 #include <linux/crc32.h>
@@ -172,7 +170,7 @@ static int ep_test_dma_probe(struct pci_dev *pdev,
 		return ret;
 	}
 
-#if defined(NV_PCI_ENABLE_PCIE_ERROR_REPORTING_PRESENT) /* Linux 6.5 */
+#if !defined(NV_DROP_PCIE_ERROR_REPORTING)
 	pci_enable_pcie_error_reporting(pdev);
 #endif