* Amlogic HDMI Tx control glue

Required properties:
- compatible: "amlogic,g12a-tohdmitx" or
	      "amlogic,sm1-tohdmitx"
- reg: physical base address of the controller and length of memory
       mapped region.
- #sound-dai-cells: should be 1.
- resets: phandle to the dedicated reset line of the hdmitx glue.

Example on the S905X2 SoC:

tohdmitx: audio-controller@744 {
	compatible = "amlogic,g12a-tohdmitx";
	reg = <0x0 0x744 0x0 0x4>;
	#sound-dai-cells = <1>;
	resets = <&clkc_audio AUD_RESET_TOHDMITX>;
};

Example of an 'amlogic,axg-sound-card':

sound {
	compatible = "amlogic,axg-sound-card";

[...]

	dai-link-x {
		sound-dai = <&tdmif_a>;
		dai-format = "i2s";
		dai-tdm-slot-tx-mask-0 = <1 1>;

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

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

	dai-link-y {
		sound-dai = <&tdmif_c>;
		dai-format = "i2s";
		dai-tdm-slot-tx-mask-0 = <1 1>;

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

	dai-link-z {
		sound-dai = <&tohdmitx TOHDMITX_I2S_OUT>;

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