/*
 * Copyright 2012 ST-Ericsson AB
 *
 * The code contained herein is licensed under the GNU General Public
 * License. You may obtain a copy of the GNU General Public License
 * Version 2 or later at the following locations:
 *
 * http://www.opensource.org/licenses/gpl-license.html
 * http://www.gnu.org/copyleft/gpl.html
 */

#include <dt-bindings/interrupt-controller/irq.h>
#include "ste-dbx5x0.dtsi"
#include "ste-href-family-pinctrl.dtsi"

/ {
	memory {
		reg = <0x00000000 0x20000000>;
	};

	gpio_keys {
		compatible = "gpio-keys";
		#address-cells = <1>;
		#size-cells = <0>;

		button@1 {
			linux,code = <11>;
			label = "SFH7741 Proximity Sensor";
		};
	};

	soc {
		uart@80120000 {
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&uart0_default_mode>;
			pinctrl-1 = <&uart0_sleep_mode>;
			status = "okay";
		};

		uart@80121000 {
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&uart1_default_mode>;
			pinctrl-1 = <&uart1_sleep_mode>;
			status = "okay";
		};

		uart@80007000 {
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&uart2_default_mode>;
			pinctrl-1 = <&uart2_sleep_mode>;
			status = "okay";
		};

		i2c@80128000 {
			lp5521@33 {
				compatible = "national,lp5521";
				reg = <0x33>;
				label = "lp5521_pri";
				clock-mode = /bits/ 8 <2>;
				chan0 {
					led-cur = /bits/ 8 <0x2f>;
					max-cur = /bits/ 8 <0x5f>;
					linux,default-trigger = "heartbeat";
				};
				chan1 {
					led-cur = /bits/ 8 <0x2f>;
					max-cur = /bits/ 8 <0x5f>;
				};
				chan2 {
					led-cur = /bits/ 8 <0x2f>;
					max-cur = /bits/ 8 <0x5f>;
				};
			};
			lp5521@34 {
				compatible = "national,lp5521";
				reg = <0x34>;
				label = "lp5521_sec";
				clock-mode = /bits/ 8 <2>;
				chan0 {
					led-cur = /bits/ 8 <0x2f>;
					max-cur = /bits/ 8 <0x5f>;
				};
				chan1 {
					led-cur = /bits/ 8 <0x2f>;
					max-cur = /bits/ 8 <0x5f>;
				};
				chan2 {
					led-cur = /bits/ 8 <0x2f>;
					max-cur = /bits/ 8 <0x5f>;
				};
			};
			bh1780@29 {
				compatible = "rohm,bh1780gli";
				reg = <0x29>;
			};
		};

		// External Micro SD slot
		sdi0_per1@80126000 {
			arm,primecell-periphid = <0x10480180>;
			max-frequency = <100000000>;
			bus-width = <4>;
			mmc-cap-sd-highspeed;
			mmc-cap-mmc-highspeed;
			vmmc-supply = <&ab8500_ldo_aux3_reg>;
			vqmmc-supply = <&vmmci>;

			cd-gpios  = <&tc3589x_gpio 3 0x4>;

			status = "okay";
		};

		// WLAN SDIO channel
		sdi1_per2@80118000 {
			arm,primecell-periphid = <0x10480180>;
			max-frequency = <100000000>;
			bus-width = <4>;

			status = "okay";
		};

		// PoP:ed eMMC
		sdi2_per3@80005000 {
			arm,primecell-periphid = <0x10480180>;
			max-frequency = <100000000>;
			bus-width = <8>;
			mmc-cap-mmc-highspeed;

			status = "okay";
		};

		// On-board eMMC
		sdi4_per2@80114000 {
			arm,primecell-periphid = <0x10480180>;
		        max-frequency = <100000000>;
			bus-width = <8>;
			mmc-cap-mmc-highspeed;
			vmmc-supply = <&ab8500_ldo_aux2_reg>;

			status = "okay";
		};

		sound {
			compatible = "stericsson,snd-soc-mop500";

			stericsson,cpu-dai = <&msp1 &msp3>;
			stericsson,audio-codec = <&codec>;
		};

		msp1: msp@80124000 {
			status = "okay";
		};

		msp3: msp@80125000 {
			status = "okay";
		};

		prcmu@80157000 {
			ab8500 {
				ab8500-gpio {
					compatible = "stericsson,ab8500-gpio";
				};

				ab8500-regulators {
					ab8500_ldo_aux1_reg: ab8500_ldo_aux1 {
						regulator-name = "V-DISPLAY";
					};

					ab8500_ldo_aux2_reg: ab8500_ldo_aux2 {
						regulator-name = "V-eMMC1";
					};

					ab8500_ldo_aux3_reg: ab8500_ldo_aux3 {
						regulator-name = "V-MMC-SD";
					};

					ab8500_ldo_intcore_reg: ab8500_ldo_intcore {
						regulator-name = "V-INTCORE";
					};

					ab8500_ldo_tvout_reg: ab8500_ldo_tvout {
						regulator-name = "V-TVOUT";
					};

					ab8500_ldo_usb_reg: ab8500_ldo_usb {
						regulator-name = "dummy";
					};

					ab8500_ldo_audio_reg: ab8500_ldo_audio {
						regulator-name = "V-AUD";
					};

					ab8500_ldo_anamic1_reg: ab8500_ldo_anamic1 {
						regulator-name = "V-AMIC1";
					};

					ab8500_ldo_anamic2_reg: ab8500_ldo_anamic2 {
						regulator-name = "V-AMIC2";
					};

					ab8500_ldo_dmic_reg: ab8500_ldo_dmic {
						regulator-name = "V-DMIC";
					};

					ab8500_ldo_ana_reg: ab8500_ldo_ana {
						regulator-name = "V-CSI/DSI";
					};
				};
			};
		};
	};
};
