// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2019 BayLibre, SAS
 * Author: Neil Armstrong <narmstrong@baylibre.com>
 * Copyright (c) 2019 Christian Hewitt <christianshewitt@gmail.com>
 */

/dts-v1/;

#include "meson-g12b-w400.dtsi"
#include <dt-bindings/sound/meson-g12a-tohdmitx.h>

/ {
	compatible = "azw,gtking", "amlogic,s922x", "amlogic,g12b";
	model = "Beelink GT-King";

	aliases {
		rtc0 = &rtc;
		rtc1 = &vrtc;
	};

	spdif_dit: audio-codec-1 {
		#sound-dai-cells = <0>;
		compatible = "linux,spdif-dit";
		status = "okay";
		sound-name-prefix = "DIT";
	};

	sound {
		compatible = "amlogic,axg-sound-card";
		model = "GTKING";
		audio-aux-devs = <&tdmout_b>;
		audio-routing = "TDMOUT_B IN 0", "FRDDR_A OUT 1",
				"TDMOUT_B IN 1", "FRDDR_B OUT 1",
				"TDMOUT_B IN 2", "FRDDR_C OUT 1",
				"TDM_B Playback", "TDMOUT_B OUT",
				"SPDIFOUT IN 0", "FRDDR_A OUT 3",
				"SPDIFOUT IN 1", "FRDDR_B OUT 3",
				"SPDIFOUT IN 2", "FRDDR_C OUT 3";

		assigned-clocks = <&clkc CLKID_MPLL2>,
				  <&clkc CLKID_MPLL0>,
				  <&clkc CLKID_MPLL1>;
		assigned-clock-parents = <0>, <0>, <0>;
		assigned-clock-rates = <294912000>,
				       <270950400>,
				       <393216000>;
		status = "okay";

		dai-link-0 {
			sound-dai = <&frddr_a>;
		};

		dai-link-1 {
			sound-dai = <&frddr_b>;
		};

		dai-link-2 {
			sound-dai = <&frddr_c>;
		};

		/* 8ch hdmi interface */
		dai-link-3 {
			sound-dai = <&tdmif_b>;
			dai-format = "i2s";
			dai-tdm-slot-tx-mask-0 = <1 1>;
			dai-tdm-slot-tx-mask-1 = <1 1>;
			dai-tdm-slot-tx-mask-2 = <1 1>;
			dai-tdm-slot-tx-mask-3 = <1 1>;
			mclk-fs = <256>;

			codec {
				sound-dai = <&tohdmitx TOHDMITX_I2S_IN_B>;
			};
		};

		/* spdif hdmi or toslink interface */
		dai-link-4 {
			sound-dai = <&spdifout>;

			codec-0 {
				sound-dai = <&spdif_dit>;
			};

			codec-1 {
				sound-dai = <&tohdmitx TOHDMITX_SPDIF_IN_A>;
			};
		};

		/* spdif hdmi interface */
		dai-link-5 {
			sound-dai = <&spdifout_b>;

			codec {
				sound-dai = <&tohdmitx TOHDMITX_SPDIF_IN_B>;
			};
		};

		/* hdmi glue */
		dai-link-6 {
			sound-dai = <&tohdmitx TOHDMITX_I2S_OUT>;

			codec {
				sound-dai = <&hdmi_tx>;
			};
		};
	};
};

&arb {
	status = "okay";
};

&clkc_audio {
	status = "okay";
};

&frddr_a {
	status = "okay";
};

&frddr_b {
	status = "okay";
};

&frddr_c {
	status = "okay";
};


&i2c3 {
	status = "okay";
	pinctrl-0 = <&i2c3_sda_a_pins>, <&i2c3_sck_a_pins>;
	pinctrl-names = "default";

	rtc: rtc@51 {
		compatible = "nxp,pcf8563";
		reg = <0x51>;
		wakeup-source;
	};
};

&spdifout {
	pinctrl-0 = <&spdif_out_h_pins>;
	pinctrl-names = "default";
	status = "okay";
};

&spdifout_b {
	status = "okay";
};

&tdmif_b {
	status = "okay";
};

&tdmout_b {
	status = "okay";
};

&tohdmitx {
	status = "okay";
};
