* Texas Instruments TVP5150 and TVP5151 video decoders

The TVP5150 and TVP5151 are video decoders that convert baseband NTSC and PAL
(and also SECAM in the TVP5151 case) video signals to either 8-bit 4:2:2 YUV
with discrete syncs or 8-bit ITU-R BT.656 with embedded syncs output formats.

Required Properties:
====================
- compatible:	Value must be "ti,tvp5150".
- reg:		I2C slave address.

Optional Properties:
====================
- pdn-gpios:	Phandle for the GPIO connected to the PDN pin, if any.
- reset-gpios:	Phandle for the GPIO connected to the RESETB pin, if any.

The device node must contain one 'port' child node per device physical input
and output port, in accordance with the video interface bindings defined in
Documentation/devicetree/bindings/media/video-interfaces.txt. The port nodes
are numbered as follows

	  Name		Type		Port
	--------------------------------------
	  AIP1A		sink		0
	  AIP1B		sink		1
	  Y-OUT		src		2

The device node must contain at least one sink port and the src port. Each input
port must be linked to an endpoint defined in [1]. The port/connector layout is
as follows

tvp-5150 port@0 (AIP1A)
	endpoint@0 -----------> Comp0-Con  port
	endpoint@1 ------+----> Svideo-Con port
tvp-5150 port@1 (AIP1B)  |
	endpoint@1 ------+
	endpoint@0 -----------> Comp1-Con  port
tvp-5150 port@2
	endpoint (video bitstream output at YOUT[0-7] parallel bus)

Required Endpoint Properties for parallel synchronization on output port:
=========================================================================

- hsync-active:		Active state of the HSYNC signal. Must be <1> (HIGH).
- vsync-active:		Active state of the VSYNC signal. Must be <1> (HIGH).
- field-even-active:	Field signal level during the even field data
			transmission. Must be <0>.

Note: Do not specify any of these properties if you want to use the embedded
      BT.656 synchronization.

Optional Connector Properties:
==============================

- sdtv-standards: Set the possible signals to which the hardware tries to lock
                  instead of using the autodetection mechnism. Please look at
                  [1] for more information.

[1] Documentation/devicetree/bindings/display/connector/analog-tv-connector.txt.

Example - three input sources:
#include <dt-bindings/display/sdtv-standards.h>

comp_connector_0 {
	compatible = "composite-video-connector";
	label = "Composite0";
	sdtv-standards = <SDTV_STD_PAL_M>; /* limit to pal-m signals */

	port {
		composite0_to_tvp5150: endpoint {
			remote-endpoint = <&tvp5150_to_composite0>;
		};
	};
};

comp_connector_1 {
	compatible = "composite-video-connector";
	label = "Composite1";
	sdtv-standards = <SDTV_STD_NTSC_M>; /* limit to ntsc-m signals */

	port {
		composite1_to_tvp5150: endpoint {
			remote-endpoint = <&tvp5150_to_composite1>;
		};
	};
};

svideo_connector {
	compatible = "svideo-connector";
	label = "S-Video";

	port {
		#address-cells = <1>;
		#size-cells = <0>;

		svideo_luma_to_tvp5150: endpoint@0 {
			reg = <0>;
			remote-endpoint = <&tvp5150_to_svideo_luma>;
		};

		svideo_chroma_to_tvp5150: endpoint@1 {
			reg = <1>;
			remote-endpoint = <&tvp5150_to_svideo_chroma>;
		};
	};
};

&i2c2 {
	tvp5150@5c {
		compatible = "ti,tvp5150";
		reg = <0x5c>;
		pdn-gpios = <&gpio4 30 GPIO_ACTIVE_LOW>;
		reset-gpios = <&gpio6 7 GPIO_ACTIVE_LOW>;
		#address-cells = <1>;
		#size-cells = <0>;

		port@0 {
			#address-cells = <1>;
			#size-cells = <0>;
			reg = <0>;

			tvp5150_to_composite0: endpoint@0 {
				reg = <0>;
				remote-endpoint = <&composite0_to_tvp5150>;
			};

			tvp5150_to_svideo_luma: endpoint@1 {
				reg = <1>;
				remote-endpoint = <&svideo_luma_to_tvp5150>;
			};
		};

		port@1 {
			#address-cells = <1>;
			#size-cells = <0>;
			reg = <1>;

			tvp5150_to_composite1: endpoint@0 {
				reg = <0>;
                                remote-endpoint = <&composite1_to_tvp5150>;
			};

			tvp5150_to_svideo_chroma: endpoint@1 {
				reg = <1>;
				remote-endpoint = <&svideo_chroma_to_tvp5150>;
			};
		};

		port@2 {
			reg = <2>;

			tvp5150_1: endpoint {
				remote-endpoint = <&ccdc_ep>;
			};
		};
	};
};
