/* Copyright (c) 2013-2014, 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.
 */

/include/ "msm8926.dtsi"

/ {
	qcom,msm-id = <200 0x20000>,
		      <224 0x20000>;
};

&msm_gpu {
	/* Updated chip ID */
	qcom,chipid = <0x03000512>;

	/* Bus Scale Settings */
	qcom,msm-bus,num-cases = <4>;
	qcom,msm-bus,vectors-KBps =
		<26 512 0 0>, <89 604 0 0>,
		<26 512 0 1800000>, <89 604 0 3200000>,
		<26 512 0 3600000>, <89 604 0 5120000>,
		<26 512 0 4800000>, <89 604 0 6400000>;

	/* Power levels */
	qcom,gpu-pwrlevels {
		#address-cells = <1>;
		#size-cells = <0>;

		compatible = "qcom,gpu-pwrlevels";

		qcom,gpu-pwrlevel@0 {
			reg = <0>;
			qcom,gpu-freq = <500000000>;
			qcom,bus-freq = <3>;
			qcom,io-fraction = <0>;
		};

		qcom,gpu-pwrlevel@1 {
			reg = <1>;
			qcom,gpu-freq = <320000000>;
			qcom,bus-freq = <2>;
			qcom,io-fraction = <33>;
		};

		qcom,gpu-pwrlevel@2 {
			reg = <2>;
			qcom,gpu-freq = <200000000>;
			qcom,bus-freq = <1>;
			qcom,io-fraction = <100>;
		};

		qcom,gpu-pwrlevel@3 {
			reg = <3>;
			qcom,gpu-freq = <19000000>;
			qcom,bus-freq = <0>;
			qcom,io-fraction = <0>;
		};
	};
};

&pm8226_l3 {
	regulator-max-microvolt = <1287500>;
};

&pm8226_l3_ao {
	regulator-max-microvolt = <1287500>;
};

&pm8226_l3_so {
	regulator-max-microvolt = <1287500>;
};

&apc_vreg_corner {
	/delete-property/ qcom,cpr-enable;
	/delete-property/ qcom,cpr-fuse-cond-min-volt-sel;
	/delete-property/ qcom,cpr-cond-min-voltage;
	/delete-property/ qcom,cpr-fuse-uplift-sel;
	/delete-property/ qcom,cpr-uplift-voltage;
	/delete-property/ qcom,cpr-uplift-quotient;
	/delete-property/ qcom,cpr-uplift-max-volt;
	/delete-property/ qcom,cpr-uplift-speed-bin;
	qcom,vdd-mx-vmax = <1287500>;
	qcom,vdd-mx-vmin-method = <4>;
	qcom,vdd-mx-corner-map = <1050000 1150000 1280000>;
};
