/* Copyright (c) 2017, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <dt-bindings/thermal/thermal.h>

&clock_cpucc {
	lmh_dcvs0: qcom,limits-dcvs@0 {
		compatible = "qcom,msm-hw-limits";
		interrupts = <GIC_SPI 32 IRQ_TYPE_LEVEL_HIGH>;
		qcom,affinity = <0>;
		#thermal-sensor-cells = <0>;
	};

	lmh_dcvs1: qcom,limits-dcvs@1 {
		compatible = "qcom,msm-hw-limits";
		interrupts = <GIC_SPI 33 IRQ_TYPE_LEVEL_HIGH>;
		qcom,affinity = <1>;
		#thermal-sensor-cells = <0>;
	};
};

&soc {
	qmi-tmd-devices {
		compatible = "qcom,qmi_cooling_devices";

		modem {
			qcom,instance-id = <0x0>;

			modem_pa: modem_pa {
				qcom,qmi-dev-name = "pa";
				#cooling-cells = <2>;
			};

			modem_proc: modem_proc {
				qcom,qmi-dev-name = "modem";
				#cooling-cells = <2>;
			};

			modem_current: modem_current {
				qcom,qmi-dev-name = "modem_current";
				#cooling-cells = <2>;
			};

			modem_vdd: modem_vdd {
				qcom,qmi-dev-name = "cpuv_restriction_cold";
				#cooling-cells = <2>;
			};
		};

		adsp {
			qcom,instance-id = <0x1>;

			adsp_vdd: adsp_vdd {
				qcom,qmi-dev-name = "cpuv_restriction_cold";
				#cooling-cells = <2>;
			};
		};

		cdsp {
			qcom,instance-id = <0x43>;

			cdsp_vdd: cdsp_vdd {
				qcom,qmi-dev-name = "cpuv_restriction_cold";
				#cooling-cells = <2>;
			};
		};
	};
};

&thermal_zones {
	aoss0-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&tsens0 0>;
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu0-silver-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&tsens0 1>;
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu1-silver-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&tsens0 2>;
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu2-silver-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&tsens0 3>;
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu3-silver-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 4>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpuss-0-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 5>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpuss-1-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 6>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu4-silver-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 7>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu5-silver-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 8>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu0-gold-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 9>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	cpu1-gold-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 10>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	gpu0-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens0 11>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	gpu1-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&tsens0 12>;
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	aoss1-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 0>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	mdm-dsp-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 1>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	ddr-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 2>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	wlan-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 3>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	compute-hvx-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 4>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	camera-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 5>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	mmss-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 6>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	mdm-core-usr {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 7>;
		thermal-governor = "user_space";
		trips {
			active-config0 {
				temperature = <125000>;
				hysteresis = <1000>;
				type = "passive";
			};
		};
	};

	gpu-virt-max-step {
		polling-delay-passive = <10>;
		polling-delay = <100>;
		thermal-governor = "step_wise";
		trips {
			gpu_trip0: gpu-trip0 {
				temperature = <95000>;
				hysteresis = <0>;
				type = "passive";
			};
		};
		cooling-maps {
			gpu_cdev0 {
				trip = <&gpu_trip0>;
				cooling-device =
					<&msm_gpu THERMAL_NO_LIMIT
						THERMAL_NO_LIMIT>;
			};
		};
	};

	hexa-silv-max-step {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "step_wise";
		trips {
			silver-trip {
				temperature = <120000>;
				hysteresis = <0>;
				type = "passive";
			};
		};
	};

	dual-gold-max-step {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "step_wise";
		trips {
			gold-trip {
				temperature = <120000>;
				hysteresis = <0>;
				type = "passive";
			};
		};
	};

	pop-mem-step {
		polling-delay-passive = <10>;
		polling-delay = <0>;
		thermal-sensors = <&tsens1 2>;
		thermal-governor = "step_wise";
		trips {
			pop_trip: pop-trip {
				temperature = <95000>;
				hysteresis = <0>;
				type = "passive";
			};
		};
		cooling-maps {
			pop_cdev6 {
				trip = <&pop_trip>;
				cooling-device =
					<&CPU6 THERMAL_NO_LIMIT
						(THERMAL_MAX_LIMIT-1)>;
			};
			pop_cdev7 {
				trip = <&pop_trip>;
				cooling-device =
					<&CPU7 THERMAL_NO_LIMIT
						(THERMAL_MAX_LIMIT-1)>;
			};
		};
	};

	aoss0-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 0>;
		tracks-low;
		trips {
			aoss0_trip: aoss0-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&aoss0_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu0-silver-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 1>;
		tracks-low;
		trips {
			cpu0_trip: cpu0-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpu0_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu1-silver-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 2>;
		tracks-low;
		trips {
			cpu1_trip: cpu1-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpu1_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu2-silver-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 3>;
		tracks-low;
		trips {
			cpu2_trip: cpu2-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpu2_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu3-silver-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 4>;
		tracks-low;
		trips {
			cpu3_trip: cpu3-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpu3_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpuss-0-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 5>;
		tracks-low;
		trips {
			l3_0_trip: l3-0-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&l3_0_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpuss-1-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 6>;
		tracks-low;
		trips {
			l3_1_trip: l3-1-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&l3_1_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu4-silver-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 7>;
		tracks-low;
		trips {
			cpu4_trip: cpu4-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpu4_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu5-silver-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 8>;
		tracks-low;
		trips {
			cpu5_trip: cpu5-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpu5_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu0-gold-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 9>;
		tracks-low;
		trips {
			cpug0_trip: cpug0-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpug0_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	cpu1-gold-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 10>;
		tracks-low;
		trips {
			cpug1_trip: cpug1-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&cpug1_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	gpu0-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 11>;
		tracks-low;
		trips {
			gpu0_trip_l: gpu0-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&gpu0_trip_l>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	gpu1-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens0 12>;
		tracks-low;
		trips {
			gpu1_trip_l: gpu1-trip_l {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&gpu1_trip_l>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	aoss1-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 0>;
		tracks-low;
		trips {
			aoss1_trip: aoss1-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&aoss1_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	mdm-dsp-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 1>;
		tracks-low;
		trips {
			dsp_trip: dsp-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&dsp_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	ddr-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 2>;
		tracks-low;
		trips {
			ddr_trip: ddr-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&ddr_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	wlan-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 3>;
		tracks-low;
		trips {
			wlan_trip: wlan-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&wlan_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	compute-hvx-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 4>;
		tracks-low;
		trips {
			hvx_trip: hvx-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&hvx_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	camera-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 5>;
		tracks-low;
		trips {
			camera_trip: camera-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&camera_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	mmss-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 6>;
		tracks-low;
		trips {
			mmss_trip: mmss-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&mmss_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	mdm-core-lowf {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "low_limits_floor";
		thermal-sensors = <&tsens1 7>;
		tracks-low;
		trips {
			mdm_trip: mdm-trip {
				temperature = <5000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};
		cooling-maps {
			cpu0_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&CPU0 2 2>;
			};
			cpu6_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&CPU6 (THERMAL_MAX_LIMIT-8)
							(THERMAL_MAX_LIMIT-8)>;
			};
			gpu_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&msm_gpu 4 4>;
			};
			cx_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&cx_cdev 0 0>;
			};
			mx_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&mx_cdev 0 0>;
			};
			modem_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&modem_vdd 0 0>;
			};
			adsp_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&adsp_vdd 0 0>;
			};
			cdsp_vdd_cdev {
				trip = <&mdm_trip>;
				cooling-device = <&cdsp_vdd 0 0>;
			};
		};
	};

	lmh-dcvs-01 {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&lmh_dcvs1>;

		trips {
			active-config {
				temperature = <95000>;
				hysteresis = <30000>;
				type = "passive";
			};
		};
	};

	lmh-dcvs-00 {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-governor = "user_space";
		thermal-sensors = <&lmh_dcvs0>;

		trips {
			active-config {
				temperature = <95000>;
				hysteresis = <30000>;
				type = "passive";
			};
		};
	};

	xo-therm-cpu-step {
		polling-delay-passive = <2000>;
		polling-delay = <0>;
		thermal-sensors = <&pm660_adc_tm 0x4c>;
		thermal-governor = "step_wise";

		trips {
			gold_trip0: gold-trip0 {
				temperature = <45000>;
				hysteresis = <0>;
				type = "passive";
			};
			silver_trip1: silver-trip1 {
				temperature = <50000>;
				hysteresis = <0>;
				type = "passive";
			};
		};

		cooling-maps {
			skin_cpu6 {
				trip = <&gold_trip0>;
				cooling-device =
					/* throttle from fmax to 1747200KHz */
					<&CPU6 THERMAL_NO_LIMIT
						(THERMAL_MAX_LIMIT-8)>;
			};
			skin_cpu7 {
				trip = <&gold_trip0>;
				cooling-device =
					<&CPU7 THERMAL_NO_LIMIT
						(THERMAL_MAX_LIMIT-8)>;
			};
			skin_cpu0 {
				trip = <&silver_trip1>;
				/* throttle from fmax to 1516800KHz */
				cooling-device = <&CPU0 THERMAL_NO_LIMIT 2>;
			};
			skin_cpu1 {
				trip = <&silver_trip1>;
				cooling-device = <&CPU1 THERMAL_NO_LIMIT 2>;
			};
			skin_cpu2 {
				trip = <&silver_trip1>;
				cooling-device = <&CPU2 THERMAL_NO_LIMIT 2>;
			};
			skin_cpu3 {
				trip = <&silver_trip1>;
				cooling-device = <&CPU3 THERMAL_NO_LIMIT 2>;
			};
			skin_cpu4 {
				trip = <&silver_trip1>;
				cooling-device = <&CPU4 THERMAL_NO_LIMIT 2>;
			};
			skin_cpu5 {
				trip = <&silver_trip1>;
				cooling-device = <&CPU5 THERMAL_NO_LIMIT 2>;
			};
		};
	};

	xo-therm-mdm-step {
		polling-delay-passive = <0>;
		polling-delay = <0>;
		thermal-sensors = <&pm660_adc_tm 0x4c>;
		thermal-governor = "step_wise";

		trips {
			modem_trip0: modem-trip0 {
				temperature = <44000>;
				hysteresis = <4000>;
				type = "passive";
			};
			modem_trip1: modem-trip1 {
				temperature = <46000>;
				hysteresis = <3000>;
				type = "passive";
			};
			modem_trip2: modem-trip2 {
				temperature = <48000>;
				hysteresis = <3000>;
				type = "passive";
			};
			modem_trip3: modem-trip3 {
				temperature = <55000>;
				hysteresis = <5000>;
				type = "passive";
			};
		};

		cooling-maps {
			modem_lvl1 {
				trip = <&modem_trip1>;
				cooling-device = <&modem_pa 1 1>;
			};
			modem_lvl2 {
				trip = <&modem_trip2>;
				cooling-device = <&modem_pa 2 2>;
			};
			modem_lvl3 {
				trip = <&modem_trip3>;
				cooling-device = <&modem_pa 3 3>;
			};
			modem_proc_lvl1 {
				trip = <&modem_trip0>;
				cooling-device = <&modem_proc 1 1>;
			};
			modem_proc_lvl3 {
				trip = <&modem_trip3>;
				cooling-device = <&modem_proc 3 3>;
			};
		};
	};
};
