/* Copyright (c) 2012-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.
 */

/dts-v1/;

/include/ "msm9625-v1.dtsi"

/ {
	model = "Qualcomm MSM 9625V1 MTP";
	compatible = "qcom,msm9625-mtp", "qcom,msm9625", "qcom,mtp";
	qcom,msm-id = <134 7 0>, <152 7 0>, <149 7 0>, <150 7 0>,
		      <151 7 0>, <148 7 0>, <173 7 0>, <174 7 0>,
		      <175 7 0>;

	i2c@f9925000 {
		charger@57 {
			compatible = "summit,smb137c";
			reg = <0x57>;
			summit,chg-current-ma = <1500>;
			summit,term-current-ma = <50>;
			summit,pre-chg-current-ma = <100>;
			summit,float-voltage-mv = <4200>;
			summit,thresh-voltage-mv = <3000>;
			summit,recharge-thresh-mv = <75>;
			summit,system-voltage-mv = <4250>;
			summit,charging-timeout = <382>;
			summit,pre-charge-timeout = <48>;
			summit,therm-current-ua = <10>;
			summit,temperature-min = <4>; /*  0 C */
			summit,temperature-max = <3>; /* 45 C */
		};
	};

	wlan0: qca,wlan {
		cell-index = <0>;
		compatible = "qca,ar6004-sdio";
		qca,chip-pwd-l-gpios = <&msmgpio 62 0>;
		qca,pm-enable-gpios = <&pm8019_gpios 3 0x0>;
		qca,vdd-io-supply = <&pm8019_l11>;
	};

	qca,wlan_ar6003 {
		cell-index = <0>;
		compatible = "qca,ar6003-sdio";
		qca,chip-pwd-l-gpios = <&msmgpio 62 0>;
		qca,pm-enable-gpios = <&pm8019_gpios 3 0x0>;
		qca,vdd-io-supply = <&pm8019_l11>;
	};
};

/* PM8019 GPIO and MPP configuration */
&pm8019_gpios {
	gpio@c000 { /* GPIO 1 */
	};

	gpio@c100 { /* GPIO 2 */
	};

	gpio@c200 { /* GPIO 3 */
	};

	gpio@c300 { /* GPIO 4 */
		/* ext_2p95v regulator enable config */
		qcom,mode = <1>; /* Digital output */
		qcom,output-type = <0>; /* CMOS */
		qcom,invert = <0>; /* Output low */
		qcom,out-strength = <1>; /* Low */
		qcom,vin-sel = <2>; /* PM8019 L11 - 1.8V */
		qcom,src-sel = <0>; /* Constant */
		qcom,master-en = <1>; /* Enable GPIO */
	};

	gpio@c400 { /* GPIO 5 */
	};

	gpio@c500 { /* GPIO 6 */
	};
};

&pm8019_mpps {
	mpp@a000 { /* MPP 1 */
	};

	mpp@a100 { /* MPP 2 */
	};

	mpp@a200 { /* MPP 3 */
	};

	mpp@a300 { /* MPP 4 */
		/* VADC channel 19 */
		qcom,mode = <4>;
		qcom,ain-route = <3>; /* AMUX 8 */
		qcom,master-en = <1>;
		qcom,src-sel = <0>; /* Function constant */
		qcom,invert = <1>;
	};

	mpp@a400 { /* MPP 5 */
	};

	mpp@a500 { /* MPP 6 */
		/* VADC channel 21 */
		qcom,mode = <4>;
		qcom,ain-route = <1>; /* AMUX 6 */
		qcom,master-en = <1>;
		qcom,src-sel = <0>; /* Function constant */
		qcom,invert = <1>;
	};
};
