// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Google Veyron Mickey Rev 0 board device tree source
 *
 * Copyright 2015 Google, Inc
 */

/dts-v1/;
#include "rk3288-veyron.dtsi"

/ {
	model = "Google Mickey";
	compatible = "google,veyron-mickey-rev8", "google,veyron-mickey-rev7",
		     "google,veyron-mickey-rev6", "google,veyron-mickey-rev5",
		     "google,veyron-mickey-rev4", "google,veyron-mickey-rev3",
		     "google,veyron-mickey-rev2", "google,veyron-mickey-rev1",
		     "google,veyron-mickey-rev0", "google,veyron-mickey",
		     "google,veyron", "rockchip,rk3288";

	vcc_5v: vcc-5v {
		vin-supply = <&vcc33_sys>;
	};

	vcc33_io: vcc33_io {
		compatible = "regulator-fixed";
		regulator-name = "vcc33_io";
		regulator-always-on;
		regulator-boot-on;
		vin-supply = <&vcc33_sys>;
	};
};

&cpu_thermal {
	/delete-node/ trips;
	/delete-node/ cooling-maps;

	trips {
		cpu_alert_almost_warm: cpu_alert_almost_warm {
			temperature = <63000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "passive";
		};
		cpu_alert_warm: cpu_alert_warm {
			temperature = <65000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "passive";
		};
		cpu_alert_almost_hot: cpu_alert_almost_hot {
			temperature = <80000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "passive";
		};
		cpu_alert_hot: cpu_alert_hot {
			temperature = <82000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "passive";
		};
		cpu_alert_hotter: cpu_alert_hotter {
			temperature = <84000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "passive";
		};
		cpu_alert_very_hot: cpu_alert_very_hot {
			temperature = <85000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "passive";
		};
		cpu_crit: cpu_crit {
			temperature = <90000>; /* millicelsius */
			hysteresis = <2000>; /* millicelsius */
			type = "critical";
		};
	};

	cooling-maps {
		/*
		 * After 1st level, throttle the CPU down to as low as 1.4 GHz
		 * and don't let the GPU go faster than 400 MHz.  Note that we
		 * won't throttle the GPU lower than 400 MHz due to CPU
		 * heat--we'll let the GPU do the rest itself.
		 */
		cpu_warm_limit_cpu {
			trip = <&cpu_alert_warm>;
			cooling-device = <&cpu0 THERMAL_NO_LIMIT 4>,
					 <&cpu1 THERMAL_NO_LIMIT 4>,
					 <&cpu2 THERMAL_NO_LIMIT 4>,
					 <&cpu3 THERMAL_NO_LIMIT 4>;
		};

		/*
		 * Add some discrete steps to help throttling system deal
		 * with the fact that there are two passive cooling devices:
		 * the CPU and the GPU.
		 *
		 * - 1.2 GHz - 1.0 GHz (almost hot)
		 * - 800 MHz           (hot)
		 * - 800 MHz - 696 MHz (hotter)
		 * - 696 MHz - min     (very hot)
		 *
		 * Note:
		 * - 800 MHz appears to be a "sweet spot" for me.  I can run
		 *   some pretty serious workload here and be happy.
		 * - After 696 MHz we stop lowering voltage, so throttling
		 *   past there is less effective.
		 */
		cpu_almost_hot_limit_cpu {
			trip = <&cpu_alert_almost_hot>;
			cooling-device = <&cpu0 5 6>, <&cpu1 5 6>, <&cpu2 5 6>,
					 <&cpu3 5 6>;
		};
		cpu_hot_limit_cpu {
			trip = <&cpu_alert_hot>;
			cooling-device = <&cpu0 7 7>, <&cpu1 7 7>, <&cpu2 7 7>,
					 <&cpu3 7 7>;
		};
		cpu_hotter_limit_cpu {
			trip = <&cpu_alert_hotter>;
			cooling-device = <&cpu0 7 8>, <&cpu1 7 8>, <&cpu2 7 8>,
					 <&cpu3 7 8>;
		};
		cpu_very_hot_limit_cpu {
			trip = <&cpu_alert_very_hot>;
			cooling-device = <&cpu0 8 THERMAL_NO_LIMIT>,
					 <&cpu1 8 THERMAL_NO_LIMIT>,
					 <&cpu2 8 THERMAL_NO_LIMIT>,
					 <&cpu3 8 THERMAL_NO_LIMIT>;
		};
	};
};

&emmc {
	/delete-property/mmc-hs200-1_8v;
};

&i2c2 {
	status = "disabled";
};

&i2c4 {
	status = "disabled";
};

&i2s {
	status = "okay";
	clock-names = "i2s_hclk", "i2s_clk", "i2s_clk_out";
	clocks = <&cru HCLK_I2S0>, <&cru SCLK_I2S0>, <&cru SCLK_I2S0_OUT>;
};

&rk808 {
	pinctrl-names = "default";
	pinctrl-0 = <&pmic_int_l &dvs_1 &dvs_2>;
	dvs-gpios = <&gpio7 RK_PB4 GPIO_ACTIVE_HIGH>,
		    <&gpio7 RK_PB7 GPIO_ACTIVE_HIGH>;

	/delete-property/ vcc6-supply;
	/delete-property/ vcc12-supply;

	vcc11-supply = <&vcc33_sys>;

	regulators {
		/* vcc33_io is sourced directly from vcc33_sys */
		/delete-node/ LDO_REG1;
		/delete-node/ LDO_REG7;

		/* This is not a pwren anymore, but the real power supply */
		vdd10_lcd: LDO_REG7 {
			regulator-always-on;
			regulator-boot-on;
			regulator-min-microvolt = <1000000>;
			regulator-max-microvolt = <1000000>;
			regulator-name = "vdd10_lcd";
			regulator-suspend-mem-disabled;
		};

		vcc18_lcd: LDO_REG8 {
			regulator-always-on;
			regulator-boot-on;
			regulator-min-microvolt = <1800000>;
			regulator-max-microvolt = <1800000>;
			regulator-name = "vcc18_lcd";
			regulator-suspend-mem-disabled;
		};
	};
};

&pinctrl {
	hdmi {
		power_hdmi_on: power-hdmi-on {
			rockchip,pins = <7 RK_PB3 RK_FUNC_GPIO &pcfg_pull_none>;
		};
	};

	pmic {
		dvs_1: dvs-1 {
			rockchip,pins = <7 RK_PB4 RK_FUNC_GPIO &pcfg_pull_down>;
		};

		dvs_2: dvs-2 {
			rockchip,pins = <7 RK_PB7 RK_FUNC_GPIO &pcfg_pull_down>;
		};
	};
};

&usb_host0_ehci {
	status = "disabled";
};

&usb_host1 {
	status = "disabled";
};

&vcc50_hdmi {
	enable-active-high;
	gpio = <&gpio7 RK_PB3 GPIO_ACTIVE_HIGH>;
	pinctrl-names = "default";
	pinctrl-0 = <&power_hdmi_on>;
};
