/* Copyright (c) 2013, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

&soc {
	mdss_mdp: qcom,mdss_mdp@fd900000 {
		compatible = "qcom,mdss_mdp";
		reg = <0xfd900000 0x22100>,
			<0xfd924000 0x1000>;
		reg-names = "mdp_phys", "vbif_phys";
		interrupts = <0 72 0>;
		vdd-supply = <&gdsc_mdss>;

		qcom,max-clk-rate = <200000000>;
		qcom,mdss-pipe-vig-off = <0x00001200>;
		qcom,mdss-pipe-rgb-off = <0x00001E00>;
		qcom,mdss-pipe-dma-off = <0x00002A00>;
		qcom,mdss-pipe-vig-fetch-id = <1>;
		qcom,mdss-pipe-rgb-fetch-id = <7>;
		qcom,mdss-pipe-dma-fetch-id = <4>;
		qcom,mdss-smp-data = <7 4096>;

		qcom,mdss-ctl-off = <0x00000600 0x00000700>;
		qcom,mdss-mixer-intf-off = <0x00003200>;
		qcom,mdss-mixer-wb-off = <0x00003E00>;
		qcom,mdss-dspp-off = <0x00004600>;
		qcom,mdss-pingpong-off = <0x00021B00>;
		qcom,mdss-wb-off = <0x00011100 0x00013100>;
		qcom,mdss-intf-off = <0x00000000 0x00021300>;
		qcom,mdss-rot-block-size = <64>;
		qcom,mdss-smp-mb-per-pipe = <2>;
		vdd-cx-supply = <&pm8226_s1_corner>;

		qcom,vbif-settings = <0x004 0x00000001>,
				     <0x0D8 0x00000707>,
				     <0x124 0x00000003>;
		qcom,mdp-settings = <0x02E0 0x000000A5>,
				    <0x02E4 0x00000055>;

		mdss_fb0: qcom,mdss_fb_primary {
			cell-index = <0>;
			compatible = "qcom,mdss-fb";
			qcom,memory-reservation-type = "EBI1";
			qcom,memory-reservation-size = <0x800000>;
			qcom,memblock-reserve = <0x03200000 0xFA0000>;
		};

		mdss_fb1: qcom,mdss_fb_wfd {
			cell-index = <1>;
			compatible = "qcom,mdss-fb";
		};
	};

	mdss_dsi0: qcom,mdss_dsi@fd922800 {
		compatible = "qcom,mdss-dsi-ctrl";
		label = "MDSS DSI CTRL->0";
		cell-index = <0>;
		reg = <0xfd922800 0x600>;
		qcom,mdss-fb-map = <&mdss_fb0>;
		qcom,mdss-mdp = <&mdss_mdp>;
		vdd-supply = <&pm8226_l15>;
		vddio-supply = <&pm8226_l8>;
		vdda-supply = <&pm8226_l4>;
		qcom,platform-reset-gpio = <&msmgpio 25 0>;
		qcom,platform-te-gpio = <&msmgpio 24 0>;
		qcom,platform-strength-ctrl = [ff 06];
		qcom,platform-bist-ctrl = [00 00 b1 ff 00 00];
		qcom,platform-regulator-settings = [07 09 03 00 20 00 01];
		qcom,platform-lane-config = [00 00 00 00 00 00 00 01 97
			00 00 00 00 05 00 00 01 97
			00 00 00 00 0a 00 00 01 97
			00 00 00 00 0f 00 00 01 97
			00 c0 00 00 00 00 00 01 bb];
		qcom,platform-supply-entry1 {
			qcom,supply-name = "vdd";
			qcom,supply-min-voltage = <2800000>;
			qcom,supply-max-voltage = <2800000>;
			qcom,supply-enable-load = <100000>;
			qcom,supply-disable-load = <100>;
			qcom,supply-pre-on-sleep = <0>;
			qcom,supply-post-on-sleep = <0>;
			qcom,supply-pre-off-sleep = <0>;
			qcom,supply-post-off-sleep = <0>;
		};
		qcom,platform-supply-entry2 {
			qcom,supply-name = "vddio";
			qcom,supply-min-voltage = <1800000>;
			qcom,supply-max-voltage = <1800000>;
			qcom,supply-enable-load = <100000>;
			qcom,supply-disable-load = <100>;
			qcom,supply-pre-on-sleep = <0>;
			qcom,supply-post-on-sleep = <0>;
			qcom,supply-pre-off-sleep = <0>;
			qcom,supply-post-off-sleep = <0>;
		};
		qcom,platform-supply-entry3 {
			qcom,supply-name = "vdda";
			qcom,supply-min-voltage = <1200000>;
			qcom,supply-max-voltage = <1200000>;
			qcom,supply-enable-load = <100000>;
			qcom,supply-disable-load = <100>;
			qcom,supply-pre-on-sleep = <0>;
			qcom,supply-post-on-sleep = <20>;
			qcom,supply-pre-off-sleep = <0>;
			qcom,supply-post-off-sleep = <0>;
		};
	};

	qcom,mdss_wb_panel {
		compatible = "qcom,mdss_wb";
		qcom,mdss_pan_res = <1280 720>;
		qcom,mdss_pan_bpp = <24>;
		qcom,mdss-fb-map = <&mdss_fb1>;
	};
};

/include/ "msm8226-mdss-panels.dtsi"
