/*
 * Copyright (C) 2015 CompuLab, Ltd. - http://www.compulab.co.il/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

/ {
	model = "CompuLab SB-SOM";
	compatible = "compulab,sb-som";

	vsb_3v3: fixedregulator-v3_3 {
		compatible = "regulator-fixed";
		regulator-name = "vsb_3v3";
		regulator-min-microvolt = <3300000>;
		regulator-max-microvolt = <3300000>;
		regulator-always-on;
		enable-active-high;
	};

	lcd0: display {
		compatible = "startek,startek-kd050c", "panel-dpi";
		label = "lcd";

		panel-timing {
			clock-frequency = <33000000>;
			hactive = <800>;
			vactive = <480>;
			hfront-porch = <40>;
			hback-porch = <40>;
			hsync-len = <43>;
			vback-porch = <29>;
			vfront-porch = <13>;
			vsync-len = <3>;
			hsync-active = <0>;
			vsync-active = <0>;
			de-active = <1>;
			pixelclk-active = <1>;
		};
	};

	hdmi_conn: connector@0 {
		compatible = "hdmi-connector";
		label = "hdmi";

		type = "a";
	};
};
