// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 Amlogic, Inc. All rights reserved.
 */

/dts-v1/;

#include "meson-g12a.dtsi"
#include "partition_mbox_normal.dtsi"
#include "mesong12a_skt-panel.dtsi"
/ {
	compatible = "amlogic,u200", "amlogic,g12a";
	model = "Amlogic Meson G12A U200 Development Board";

	aliases {
		serial0 = &uart_AO;
		serial1 = &uart_A;
		serial2 = &uart_B;
		serial3 = &uart_C;
		serial4 = &uart_AO_B;
		i2c0 = &i2c0;
		i2c1 = &i2c1;
		i2c2 = &i2c2;
		i2c3 = &i2c3;
		i2c4 = &i2c_AO;
		spi0 = &spifc;
		spi1 = &spicc0;
		spi2 = &spicc1;
		tsensor0 = &p_tsensor;
	};
	chosen {
		stdout-path = "serial0:115200n8";
	};
	memory@0 {
		device_type = "memory";
		linux,usable-memory = <0x0 0x40000000>;
	};

	reserved-memory {
		#address-cells = <1>;
		#size-cells = <1>;
		ranges;
		secmon_reserved:linux,secmon {
			compatible = "shared-dma-pool";
			reusable;
			size = <0x400000>;
			alignment = <0x400000>;
			alloc-ranges = <0x05000000 0x400000>;
		};

		ramoops@0x07400000 {
			compatible = "ramoops";
			reg = <0x07400000 0x00100000>;
			record-size = <0x8000>;
			console-size = <0x8000>;
			ftrace-size = <0x80000>;
			pmsg-size = <0x8000>;
			no-map;
		};

		logo_reserved:linux,meson-fb {
			compatible = "shared-dma-pool";
			reusable;
			size = <0x800000>;
			alignment = <0x400000>;
			alloc-ranges = <0x3f800000 0x800000>;
		};

		ion_cma_reserved:linux,ion-dev {
			compatible = "shared-dma-pool";
			reusable;
			size = <0x8000000>;
			alignment = <0x400000>;
			alloc-ranges = <0x30000000 0x50000000>;
		};
		/*  POST PROCESS MANAGER */
		ppmgr_reserved:linux,ppmgr {
			compatible = "shared-dma-pool";
			size = <0x0>;
		};

		codec_mm_cma:linux,codec_mm_cma {
			compatible = "shared-dma-pool";
			reusable;
			/* ion_codec_mm max can alloc size 80M*/
			size = <0x13400000>;
			alignment = <0x400000>;
			linux,contiguous-region;
			alloc-ranges = <0x30000000 0x50000000>;
		};
		/* codec shared reserved */
		codec_mm_reserved:linux,codec_mm_reserved {
			compatible = "amlogic, codec-mm-reserved";
			size = <0x0>;
			alignment = <0x100000>;
			//no-map;
		};

		picdec_cma_reserved:linux,picdec {
			compatible = "shared-dma-pool";
			reusable;
			size = <0x0>;
			alignment = <0x0>;
			linux,contiguous-region;
		};
	};

	main_12v: regulator-main_12v {
		compatible = "regulator-fixed";
		regulator-name = "12V";
		regulator-min-microvolt = <12000000>;
		regulator-max-microvolt = <12000000>;
		regulator-always-on;
	};

	vcc_3v3: regulator-vcc_3v3 {
		compatible = "regulator-fixed";
		regulator-name = "VCC_3V3";
		regulator-min-microvolt = <3300000>;
		regulator-max-microvolt = <3300000>;
		vin-supply = <&vddao_3v3>;
		regulator-always-on;
	};

	vcc_5v: regulator-vcc_5v {
		compatible = "regulator-fixed";
		regulator-name = "VCC5V";
		regulator-min-microvolt = <5000000>;
		regulator-max-microvolt = <5000000>;
		vin-supply = <&main_12v>;
		regulator-always-on;
	};

	vddao_3v3: regulator-vddao_3v3 {
		compatible = "regulator-fixed";
		regulator-name = "VDDAO_3V3";
		regulator-min-microvolt = <3300000>;
		regulator-max-microvolt = <3300000>;
		vin-supply = <&main_12v>;
		regulator-always-on;
	};

	vddio_ao18: regulator-vddio_ao18 {
		compatible = "regulator-fixed";
		regulator-name = "VDDIO_AO18";
		regulator-min-microvolt = <1800000>;
		regulator-max-microvolt = <1800000>;
		vin-supply = <&vddao_3v3>;
		regulator-always-on;
	};

	vddio_boot: regulator-vddio_boot {
		compatible = "regulator-fixed";
		regulator-name = "VDDIO_BOOT";
		regulator-min-microvolt = <1800000>;
		regulator-max-microvolt = <1800000>;
		vin-supply = <&vddao_3v3>;
		regulator-always-on;
	};

	/*DCDC for MP8756GD*/
	cpu_opp_table0: cpu_opp_table0 {
		compatible = "operating-points-v2";
		opp-shared;

		opp00 {
			opp-hz = /bits/ 64 <100000000>;
			opp-microvolt = <731000>;
		};
		opp01 {
			opp-hz = /bits/ 64 <250000000>;
			opp-microvolt = <731000>;
		};
		opp02 {
			opp-hz = /bits/ 64 <500000000>;
			opp-microvolt = <731000>;
		};
		opp03 {
			opp-hz = /bits/ 64 <667000000>;
			opp-microvolt = <731000>;
		};
		opp04 {
			opp-hz = /bits/ 64 <1000000000>;
			opp-microvolt = <731000>;
		};
		opp05 {
			opp-hz = /bits/ 64 <1200000000>;
			opp-microvolt = <731000>;
		};
		opp06 {
			opp-hz = /bits/ 64 <1398000000>;
			opp-microvolt = <761000>;
		};
		opp07 {
			opp-hz = /bits/ 64 <1512000000>;
			opp-microvolt = <791000>;
		};
		opp08 {
			opp-hz = /bits/ 64 <1608000000>;
			opp-microvolt = <831000>;
		};
		opp09 {
			opp-hz = /bits/ 64 <1704000000>;
			opp-microvolt = <861000>;
		};
		opp10 {
			opp-hz = /bits/ 64 <1800000000>;
			opp-microvolt = <981000>;
		};
	};

	cpufreq-meson {
		compatible = "amlogic, cpufreq-meson";
		pinctrl-names = "default";
		pinctrl-0 = <&pwm_ao_d_pins3>;
		status = "okay";
	};

	dvb {
		compatible = "amlogic, dvb";
		dev_name = "dvb";
		status = "ok";

		dmx = <&demux>;
		key_endia = <0>;
		add_s2p2 = <0>;
		add_ts_in = <0>;
		add_asyncfifo = <0>;
/*
 *		ts0 = "serial";
 *		ts0_control = <0x800>;
 *		ts0_invert = <0>;
 *		pinctrl-names = "s_ts0";
 *		pinctrl-0 = <&dvb_s_ts0_pins>;
 */
	};
	dvbfe {
		compatible = "amlogic, dvbfe";
		dev_name = "dvbfe";
		dtv_demod0 = "Avl6762";
		dtv_demod0_i2c_adap = <&i2c3>;
		dtv_demod0_i2c_addr = <0x14>;
		dtv_demod0_reset_value = <0>;
		dtv_demod0_reset_gpio = <&gpio GPIOZ_10 GPIO_ACTIVE_HIGH>;
		dtv_demod0_ant_poweron_value = <0>;
		dtv_demod0_ant_power_gpio = <&gpio GPIOH_5 GPIO_ACTIVE_HIGH>;
		dtv_demod0_tuner_type = <52>;
		fe0_dtv_demod = <0>;
		fe0_ts  = <0>;
		fe0_dev = <0>;
	};
	meson_cooldev: meson-cooldev@0 {
		status = "okay";
		compatible = "amlogic, meson-cooldev";
		cooling_devices {
			cpucore_cool_cluster0 {
				cluster_id = <0>;
				device_type = "cpucore";
				node_name = "cpucore0";
			};
		};
		cpucore0:cpucore0 {
			#cooling-cells = <2>;
		};
	};
	/*meson cooling devices end*/
	thermal-zones {
		soc_thermal: soc_thermal {
			polling-delay = <1000>;
			polling-delay-passive = <100>;
			sustainable-power = <1460>;
			thermal-sensors = <&p_tsensor 0>;
			trips {
				pswitch_on: trip-point@0 {
					temperature = <60000>;
					hysteresis = <2000>;
					type = "passive";
				};
				pcontrol: trip-point@1 {
					temperature = <75000>;
					hysteresis = <2000>;
					type = "passive";
				};
				phot: trip-point@2 {
					temperature = <85000>;
					hysteresis = <5000>;
					type = "hot";
				};
				pcritical: trip-point@3 {
					temperature = <110000>;
					hysteresis = <1000>;
					type = "critical";
				};
			};
			cooling-maps {
				cpufreq_cooling_map {
					trip = <&pcontrol>;
					cooling-device = <&cpu0 0 6>;
					contribution = <1024>;
				};
				cpucore_cooling_map {
					trip = <&pcontrol>;
					cooling-device = <&cpucore0 0 2>;
					contribution = <1024>;
				};
			};
		};

	};

	gpioleds {
		compatible = "gpio-leds";
		status = "okay";

		sys_led {
			label="sys_led";
			gpios=<&gpio_ao GPIOAO_11 GPIO_ACTIVE_HIGH>;
			default-state ="on";
		};
	};

	codec_mm {
		compatible = "amlogic, codec, mm";
		memory-region = <&codec_mm_cma &codec_mm_reserved>;
		dev_name = "codec_mm";
		status = "okay";
	};

	picdec {
		compatible = "amlogic, picdec";
		memory-region = <&picdec_cma_reserved>;
		dev_name = "picdec";
		status = "okay";
	};

	videocapture_0 {
		compatible = "amlogic, videocapture";
		dev_name = "videocapture";
		status = "okay";
		videocapture_id = <0>;
		cma_mode = <1>;
	};

	videocapture_1 {
		compatible = "amlogic, videocapture";
		dev_name = "videocapture";
		status = "okay";
		videocapture_id = <1>;
		cma_mode = <1>;
	};

	gpio_keypad{
		compatible = "amlogic, gpio_keypad";
		status = "okay";
		scan_period = <20>;
		key_num = <1>;
		key_name = "power";
		key_code = <116>;
		key-gpios = <&gpio_ao  GPIOAO_3  GPIO_ACTIVE_HIGH>;
		detect_mode = <0>;/*0:polling mode, 1:irq mode*/
	};

	adc_keypad {
		compatible = "amlogic, adc_keypad";
		status = "okay";
		key_name = "vol-", "vol+", "enter";
		key_num = <3>;
		io-channels = <&saradc 2>;
		io-channel-names = "key-chan-2";
		key_chan = <2 2 2>;
		key_code = <114 115 28>;
		key_val = <143 266 389>; //val=voltage/1800mV*1023
		key_tolerance = <40 40 40>;
	};

	/* Audio Related start */
	pdm_codec:pdm_codec {
		#sound-dai-cells = <0>;
		compatible = "amlogic, pdm_dummy_codec";

		status = "okay";
	};

	dummy_codec:dummy_codec {
		#sound-dai-cells = <0>;
		compatible = "amlogic, aml_dummy_codec";

		status = "okay";
	};

	amlogic_codec:t9015 {
		#sound-dai-cells = <0>;
		compatible = "amlogic, aml_codec_T9015";
		status = "okay";

		reg = <0xFF632000 0x2000>;
		is_auge_used = <1>; /* meson or auge chipset used */
		tdmout_index = <1>;
	};

	auge_sound {
		compatible = "amlogic, g12a-sound-card";
		aml-audio-card,name = "AML-AUGESOUND";
		status = "okay";

		//aml-audio-card,aux-devs = <&amlogic_codec>;
		/*avout mute gpio*/
		avout_mute-gpios = <&gpio_ao GPIOAO_2 GPIO_ACTIVE_HIGH>;
		/*for audio effect ,eqdrc */
		//aml-audio-card,effect = <&audio_effect>;

		aml-audio-card,dai-link@0 {
			format = "dsp_a";
			mclk-fs = <512>;
			//continuous-clock;
			//bitclock-inversion;
			//frame-inversion;
			//bitclock-master = <&tdmacodec>;
			//frame-master = <&tdmacodec>;
			/* suffix-name, sync with android audio hal
			 * what's the dai link used for
			 */
			suffix-name = "alsaPORT-pcm";
			tdmacpu: cpu {
				sound-dai = <&tdma>;
				dai-tdm-slot-tx-mask =
							<1 1 1 1 1 1 1 1>;
				dai-tdm-slot-rx-mask =
							<1 1 1 1 1 1 1 1>;
				dai-tdm-slot-num = <8>;
				dai-tdm-slot-width = <32>;
				system-clock-frequency = <24576000>;
			};
			tdmacodec: codec {
				sound-dai = <&dummy_codec>;
			};
		};

		aml-audio-card,dai-link@1 {
			format = "i2s";// "dsp_a";
			mclk-fs = <256>;
			//continuous-clock;
			//bitclock-inversion;
			//frame-inversion;
			bitclock-master = <&tdmb>;
			frame-master = <&tdmb>;
			//bitclock-master = <&tdmbcodec>;
			//frame-master = <&tdmbcodec>;
			/* suffix-name, sync with android audio hal
			 * what's the dai link used for
			 */
			suffix-name = "alsaPORT-i2s";
			cpu {
				sound-dai = <&tdmb>;
				dai-tdm-slot-tx-mask = <1 1>;
				dai-tdm-slot-rx-mask = <1 1>;
				dai-tdm-slot-num = <2>;
				/*
				 * dai-tdm-slot-tx-mask =
				 *	<1 1 1 1 1 1 1 1>;
				 * dai-tdm-slot-rx-mask =
				 *	<1 1 1 1 1 1 1 1>;
				 * dai-tdm-slot-num = <8>;
				 */
				dai-tdm-slot-width = <32>;
				system-clock-frequency = <12288000>;
			};
			tdmbcodec: codec {
				sound-dai = <&amlogic_codec &ad82584f_62>;
			};
		};

		aml-audio-card,dai-link@2 {
			format = "i2s";
			mclk-fs = <256>;
			//continuous-clock;
			//bitclock-inversion;
			//frame-inversion;
			bitclock-master = <&tdmc>;
			frame-master = <&tdmc>;
			/* suffix-name, sync with android audio hal
			 * what's the dai link used for
			 */
			//suffix-name = "alsaPORT-tdm";
			cpu {
				sound-dai = <&tdmc>;
				dai-tdm-slot-tx-mask = <1 1>;
				dai-tdm-slot-rx-mask = <1 1>;
				dai-tdm-slot-num = <2>;
				dai-tdm-slot-width = <32>;
				system-clock-frequency = <12288000>;
			};
			codec {
				sound-dai = <&tlv320adc3101_32 &dummy_codec>;
			};
		};

		aml-audio-card,dai-link@3 {
			mclk-fs = <64>;
			/* suffix-name, sync with android audio hal
			 * what's the dai link used for
			 */
			suffix-name = "alsaPORT-pdm";
			cpu {
				sound-dai = <&pdm>;
			};
			codec {
				sound-dai = <&pdm_codec>;
			};
		};

		aml-audio-card,dai-link@4 {
			mclk-fs = <128>;
			continuous-clock;
			/* suffix-name, sync with android audio hal
			 * what's the dai link used for
			 */
			suffix-name = "alsaPORT-spdifb2hdmi";
			cpu {
				sound-dai = <&spdifa>;
				system-clock-frequency = <6144000>;
			};
			codec {
				sound-dai = <&dummy_codec>;
			};
		};

		/* spdif_b to hdmi, only playback */
		aml-audio-card,dai-link@5 {
			mclk-fs = <128>;
			continuous-clock;
			/* suffix-name, sync with android audio hal
			 * what's the dai link used for
			 */
			suffix-name = "alsaPORT-spdif";
			cpu {
				sound-dai = <&spdifb>;
				system-clock-frequency = <6144000>;
			};
			codec {
				sound-dai = <&dummy_codec>;
			};
		};
	};

	/* Audio Related end */
};

&pwm_AO_cd {
	status = "okay";
};

&uart_AO {
	status = "okay";
};

&dwc2_a {
	status = "okay";
	/** 0: normal, 1: otg+dwc3 host only, 2: otg+dwc3 device only*/
	controller-type = <3>;
};

&usb0 {
	status = "okay";
};

&usb2_phy_v2 {
	status = "okay";
	portnum = <2>;
};

&usb3_phy_v2 {
	status = "okay";
	portnum = <1>;
	otg = <1>;
	gpio-vbus-power = "GPIOH_6";
	gpios = <&gpio GPIOH_6 GPIO_ACTIVE_HIGH>;
};

&pcie {
	reset-gpio = <&gpio GPIOX_7 GPIO_ACTIVE_HIGH>;
	status = "disabled";
};

&i2c0 {
	status = "disabled";
};

&i2c1 {
	status = "disabled";
};

&i2c2 {
	status = "disabled";
};

&i2c3 {
	status = "okay";
	pinctrl-names="default";
	pinctrl-0=<&i2c3_master_pins2>;
	clock-frequency = <100000>; /* default 100k */

	/* for ref board */
	ad82584f_62: ad82584f_62@62 {
		compatible = "ESMT, ad82584f";
		#sound-dai-cells = <0>;
		reg = <0x31>;
		reset_pin = <&gpio GPIOA_5 0>;

		status = "okay";
	};

	tlv320adc3101_32: tlv320adc3101_32@32 {
		compatible = "ti,tlv320adc3101";
		#sound-dai-cells = <0>;
		reg = <0x19>;
		differential_pair = <1>;

		status = "okay";
	};

};

&i2c_AO {
	status = "disabled";
};

&spifc {
	status = "disabled";
	pinctrl-names = "default";
	pinctrl-0 = <&spifc_pins>;
	spi-nand@0 {
		compatible = "spi-nand";
		status = "disabled";
		reg = <0>;
		spi-max-frequency = <16000000>;
	};
};

&spicc1 {
	status = "disabled";
	pinctrl-names = "default";
	pinctrl-0 = <&spicc1_pins>;
	cs-gpios = <&gpio GPIOH_6 0>;
};

/* Audio Related start */
&audiobus {
	status = "okay";

	tdma: tdm@0 {
		compatible = "amlogic, g12a-snd-tdma";
		#sound-dai-cells = <0>;
		dai-tdm-lane-slot-mask-in = <0 1>;
		dai-tdm-oe-lane-slot-mask-out = <1 0>;
		dai-tdm-clk-sel = <0>;
		clocks = <&clkaudio CLKID_AUDIO_MCLK_A
				&clkc CLKID_MPLL0>;
		clock-names = "mclk", "clk_srcpll";
		pinctrl-names = "tdm_pins";
		pinctrl-0 = <&tdmout_a &tdmin_a>;

		status = "okay";
	};

	tdmb: tdm@1 {
		compatible = "amlogic, g12a-snd-tdmb";
		#sound-dai-cells = <0>;
		dai-tdm-lane-slot-mask-in = <0 1 0 0>;
		dai-tdm-lane-slot-mask-out = <1 0 0 0>;
		dai-tdm-clk-sel = <1>;
		clocks = <&clkaudio CLKID_AUDIO_MCLK_B
				&clkc CLKID_MPLL1
				&clkc CLKID_MPLL0
				&clkaudio CLKID_AUDIO_SPDIFOUT_CTRL>;
		clock-names = "mclk", "clk_srcpll",
			"samesource_srcpll", "samesource_clk";
		pinctrl-names = "tdm_pins";
		pinctrl-0 = <&tdmb_mclk &tdmout_b &tdmin_b>;
		mclk_pad = <0>;  /* 0: mclk_0; 1: mclk_1 */
		/*
		 * 0: tdmout_a;
		 * 1: tdmout_b;
		 * 2: tdmout_c;
		 * 3: spdifout;
		 * 4: spdifout_b;
		 */
		samesource_sel = <3>;

		status = "okay";
	};

	tdmc: tdm@2 {
		compatible = "amlogic, g12a-snd-tdmc";
		#sound-dai-cells = <0>;
		dai-tdm-lane-slot-mask-in = <1 0 0 0>;
		#dai-tdm-lane-slot-mask-out = <1 0 1 1>;
		#dai-tdm-lane-oe-slot-mask-in = <0 0 0 0>;
		#dai-tdm-lane-oe-slot-mask-out = <1 0 0 0>;
		dai-tdm-clk-sel = <2>;
		clocks = <&clkaudio CLKID_AUDIO_MCLK_C
				&clkc CLKID_MPLL2>;
		clock-names = "mclk", "clk_srcpll";
		pinctrl-names = "tdm_pins";
		pinctrl-0 = <&tdmc_mclk &tdmout_c &tdmin_c>;
		mclk_pad = <1>;  /* 0: mclk_0; 1: mclk_1 */

		status = "okay";
	};

	tdmlb: tdm@3 {
		compatible = "amlogic, g12a-snd-tdmlb";
		#sound-dai-cells = <0>;
		dai-tdm-lane-lb-slot-mask-in = <1 0 0 0>;
		dai-tdm-clk-sel = <1>;
		clocks = <&clkaudio CLKID_AUDIO_MCLK_B
				&clkc CLKID_MPLL1>;
		clock-names = "mclk", "clk_srcpll";
		/*
		 * select tdmin_lb src;
		 *0: TDMOUTA
		 *1: TDMOUTB
		 *2: TDMOUTC
		 *3: PAD_TDMINA
		 *4: PAD_TDMINB
		 *5: PAD_TDMINC
		 */
		lb-src-sel = <1>;

		status = "disabled";
	};

	spdifa: spdif@0 {
		compatible = "amlogic, g12a-snd-spdif-a";
		#sound-dai-cells = <0>;
		clocks = <&clkc CLKID_MPLL0
				&clkc CLKID_FCLK_DIV4
				&clkaudio CLKID_AUDIO_SPDIFIN
				&clkaudio CLKID_AUDIO_SPDIFOUT
				&clkaudio CLKID_AUDIO_SPDIFIN_CTRL
				&clkaudio CLKID_AUDIO_SPDIFOUT_CTRL>;
		clock-names = "sysclk", "fixed_clk", "gate_spdifin",
				"gate_spdifout", "clk_spdifin", "clk_spdifout";
		interrupts =
				<GIC_SPI 151 IRQ_TYPE_EDGE_RISING>;

		interrupt-names = "irq_spdifin";
		pinctrl-names = "spdif_pins",
					"spdif_pins_mute";
		pinctrl-0 = <&spdifout &spdifin>;
		pinctrl-1 = <&spdifout_a_mute>;

		status = "okay";
	};

	spdifb: spdif@1 {
		compatible = "amlogic, g12a-snd-spdif-b";
		#sound-dai-cells = <0>;
		clocks = <&clkc CLKID_MPLL0 /*CLKID_HIFI_PLL*/
				&clkaudio CLKID_AUDIO_SPDIFOUTB
				&clkaudio CLKID_AUDIO_SPDIFOUTB_CTRL>;
		clock-names = "sysclk",
				"gate_spdifout", "clk_spdifout";

		status = "okay";
	};

	pdm: pdm {
		compatible = "amlogic, g12a-snd-pdm";
		#sound-dai-cells = <0>;

		clocks = <&clkaudio CLKID_AUDIO_PDM
			&clkc CLKID_FCLK_DIV3
			&clkc CLKID_MPLL3
			&clkaudio CLKID_AUDIO_PDMIN0
			&clkaudio CLKID_AUDIO_PDMIN1>;
		clock-names = "gate",
			"sysclk_srcpll",
			"dclk_srcpll",
			"pdm_dclk",
			"pdm_sysclk";

		pinctrl-names = "pdm_pins";
		pinctrl-0 = <&pdmin>;

		lane-mask-in = <1 0 1 0>;

		filter_mode = <1>; /* mode 0~4, defalut:1 */

		status = "okay";
	};

}; /* end of audiobus */
/* Audio Related end */

&pinctrl_periphs {

	/* Audio Related start */
	tdmout_a: tdmout_a {
		mux { /* GPIOX_11, GPIOX_10, GPIOX_9 */
			groups = "tdm_a_sclk",
				"tdm_a_fs",
				"tdm_a_dout0";
			function = "tdm_a";
		};
	};

	tdmin_a: tdmin_a {
		mux { /* GPIOX_8 */
			groups = "tdm_a_din1";
			function = "tdm_a";
		};
	};

	tdmb_mclk: tdmb_mclk {
		mux {
			groups = "mclk0_a";
			function = "mclk0";
			drive-strength = <2>;
		};
	};
	tdmout_b: tdmout_b {
		mux { /* GPIOA_1, GPIOA_2, GPIOA_3 */
			groups = "tdm_b_sclk",
				"tdm_b_fs",
				"tdm_b_dout0";
			function = "tdm_b";
			drive-strength = <2>;
		};
	};

	tdmin_b:tdmin_b {
		mux { /* GPIOA_4 */
			groups = "tdm_b_din1";
			function = "tdm_b";
			drive-strength = <2>;
		};
	};

	tdmc_mclk: tdmc_mclk {
		mux { /* GPIOA_11 */
			groups = "mclk1_a";
			function = "mclk1";
		};
	};

	tdmout_c:tdmout_c {
		mux { /* GPIOA_12, GPIOA_13, GPIOA_9 */
			groups = "tdm_c_sclk_a",
				"tdm_c_fs_a",
				"tdm_c_dout1_a";
			function = "tdm_c";
		};
	};

	tdmin_c:tdmin_c {
		mux { /* GPIOA_10 */
			groups = "tdm_c_din0_a";
			function = "tdm_c";
		};
	};

	spdifin: spdifin {
		mux {/* GPIOH_5 */
			groups = "spdif_in_h";
			function = "spdif_in";
		};
	};

	/* GPIOH_4 */
	/*
	 * spdifout: spdifout {
	 *	mux {
	 *		groups = "spdif_out_h";
	 *		function = "spdif_out";
	 *	};
	 *};
	 */

	 bl_pwm_off_pins:bl_pwm_off_pin {
		mux {
			pins = "GPIOH_5";
			function = "gpio_periphs";
			output-high;
		};
	};

	pdmin: pdmin {
		mux { /* GPIOA_5, GPIOA_6, GPIOA_7, GPIOA_8, GPIOA_9 */
			groups = "pdm_din0_a",
			/*"pdm_din1_a",*/
			"pdm_din2_a",
			/*"pdm_din3_a",*/
			"pdm_dclk_a";
			function = "pdm";
		};
	};
	/* Audio Related end */

}; /* end of pinctrl_periphs */

&pinctrl_aobus {
	spdifout: spdifout {
		mux { /* gpiao_10 */
			groups = "spdif_ao_out";
			function = "spdif_ao_out";
		};
	};

	spdifout_a_mute: spdifout_a_mute {
		mux { /* gpiao_10 */
			groups = "GPIOAO_10";
			function = "gpio_aobus";
		};
	};
};  /* end of pinctrl_aobus */

&audio_data {
	status = "disabled";
};
/* Audio Related End */

/* emmc storage */
&sd_emmc_c {
	status = "okay";
	pinctrl-0 = <&emmc_pins>;
	pinctrl-1 = <&emmc_clk_gate_pins>;
	pinctrl-names = "default", "clk-gate";
	bus-width = <8>;
	cap-sd-highspeed;
	cap-mmc-highspeed;
	cap-mmc-hw-reset;
	max-frequency = <200000000>;
	non-removable;
	disable-wp;
	mmc-ddr-1_8v;
	mmc-hs200-1_8v;
	card_type = <1>;

	vmmc-supply = <&vcc_3v3>;
	vqmmc-supply = <&vddio_boot>;
};

/* SD card */
&sd_emmc_b {
	status = "okay";
	pinctrl-0 = <&sdcard_pins>;
	pinctrl-1 = <&sdcard_clk_gate_pins>;
	pinctrl-names = "default", "clk-gate";
	bus-width = <4>;
	cap-sd-highspeed;
	max-frequency = <100000000>;
	disable-wp;
	cd-gpios = <&gpio GPIOC_6 GPIO_ACTIVE_HIGH>;
	cd-inverted;
	card_type = <5>;

	vmmc-supply = <&vddao_3v3>;
	vqmmc-supply = <&vddio_boot>;
};

&ethmac {
	status = "okay";
	pinctrl-names = "internal_eth_pins";
	pinctrl-0 = <&internal_eth_pins>;
	mc_val = <0x4be04>;
	internal_phy=<1>;
};

&saradc {
	status = "okay";
	vref-supply = <&vddio_ao18>;
};

&mtd_nand {
	status = "disabled";
	partition = <&nand_partitions>;
	nand_partitions:nand_partition{
		/*
		 * if bl_mode is 1, tpl size was generate by
		 * fip_copies * fip_size which
		 * will not skip bad when calculating
		 * the partition size;
		 *
		 * if bl_mode is 0,
		 * tpl partition must be comment out.
		 */
		tpl{
			offset=<0x0 0x0>;
			size=<0x0 0x0>;
		};
		logo{
			offset=<0x0 0x0>;
			size=<0x0 0x200000>;
		};
		recovery{
			offset=<0x0 0x0>;
			size=<0x0 0x1000000>;
		};
		boot{
			offset=<0x0 0x0>;
			size=<0x0 0x4000000>;
		};
		system{
			offset=<0x0 0x0>;
			size=<0x0 0x11800000>;
		};
		data{
			offset=<0xffffffff 0xffffffff>;
			size=<0x0 0x0>;
		};
	};
};

&cvbsout {
	status = "okay";
	/* performance: reg_address, reg_value */
	/* g12a */
	performance = <0x1bf0  0x9
		0x1b56  0x333
		0x1b12  0x8080
		0x1b05  0xfd
		0x1c59  0xf850
		0xffff  0x0>; /* ending flag */
	performance_sarft = <0x1bf0  0x9
		0x1b56  0x333
		0x1b12  0x0
		0x1b05  0x9
		0x1c59  0xfc48
		0xffff  0x0>; /* ending flag */
	performance_revB_telecom = <0x1bf0  0x9
		0x1b56  0x546
		0x1b12  0x8080
		0x1b05  0x9
		0x1c59  0xf850
		0xffff  0x0>; /* ending flag */
};

&meson_fb {
	status = "okay";
	display_size_default = <1920 1080 1920 2160 32>;
	mem_size = <0x00800000 0x1980000 0x100000 0x100000 0x800000>;
	logo_addr = "0x3f800000";
	mem_alloc = <0>;
	pxp_mode = <0>; /** 0:normal mode 1:pxp mode */
};

&aml_bt {
	status = "okay";
};

&aml_wifi {
	status = "okay";
};

&pwm_ef {
	status = "okay";
};

&uart_A {
	status = "okay";
};
