// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright 2012 ST-Ericsson AB
 */

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

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

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

		/* This UART is unused and thus left disabled */
		uart@80121000 {
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&uart1_default_mode>;
			pinctrl-1 = <&uart1_sleep_mode>;
		};

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

		i2c@80004000 {
			pinctrl-names = "default","sleep";
			pinctrl-0 = <&i2c0_default_mode>;
			pinctrl-1 = <&i2c0_sleep_mode>;
		};

		i2c@80122000 {
			pinctrl-names = "default","sleep";
			pinctrl-0 = <&i2c1_default_mode>;
			pinctrl-1 = <&i2c1_sleep_mode>;
		};

		i2c@80128000 {
			pinctrl-names = "default","sleep";
			pinctrl-0 = <&i2c2_default_mode>;
			pinctrl-1 = <&i2c2_sleep_mode>;
			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>;
			};
		};

		i2c@80110000 {
			pinctrl-names = "default","sleep";
			pinctrl-0 = <&i2c3_default_mode>;
			pinctrl-1 = <&i2c3_sleep_mode>;
		};

		/* ST6G3244ME level translator for 1.8/2.9 V */
		vmmci: regulator-gpio {
			compatible = "regulator-gpio";

			regulator-min-microvolt = <1800000>;
			regulator-max-microvolt = <2900000>;
			regulator-name = "mmci-reg";
			regulator-type = "voltage";

			startup-delay-us = <100>;

			states = <1800000 0x1
				  2900000 0x0>;
		};

		// External Micro SD slot
		sdi0_per1@80126000 {
			arm,primecell-periphid = <0x10480180>;
			max-frequency = <100000000>;
			bus-width = <4>;
			cap-sd-highspeed;
			cap-mmc-highspeed;
			sd-uhs-sdr12;
			sd-uhs-sdr25;
			full-pwr-cycle;
			st,sig-dir-dat0;
			st,sig-dir-dat2;
			st,sig-dir-cmd;
			st,sig-pin-fbclk;
			vmmc-supply = <&ab8500_ldo_aux3_reg>;
			vqmmc-supply = <&vmmci>;
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&sdi0_default_mode>;
			pinctrl-1 = <&sdi0_sleep_mode>;

			status = "okay";
		};

		// WLAN SDIO channel
		sdi1_per2@80118000 {
			arm,primecell-periphid = <0x10480180>;
			max-frequency = <100000000>;
			bus-width = <4>;
			non-removable;
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&sdi1_default_mode>;
			pinctrl-1 = <&sdi1_sleep_mode>;

			status = "okay";
		};

		// PoP:ed eMMC
		sdi2_per3@80005000 {
			arm,primecell-periphid = <0x10480180>;
			max-frequency = <100000000>;
			bus-width = <8>;
			cap-mmc-highspeed;
			non-removable;
			vmmc-supply = <&db8500_vsmps2_reg>;
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&sdi2_default_mode>;
			pinctrl-1 = <&sdi2_sleep_mode>;

			status = "okay";
		};

		// On-board eMMC
		sdi4_per2@80114000 {
			arm,primecell-periphid = <0x10480180>;
		        max-frequency = <100000000>;
			bus-width = <8>;
			cap-mmc-highspeed;
			non-removable;
			vmmc-supply = <&ab8500_ldo_aux2_reg>;
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&sdi4_default_mode>;
			pinctrl-1 = <&sdi4_sleep_mode>;

			status = "okay";
		};

		msp0: msp@80123000 {
			pinctrl-names = "default";
			pinctrl-0 = <&msp0_default_mode>;
			status = "okay";
		};

		msp1: msp@80124000 {
			pinctrl-names = "default";
			pinctrl-0 = <&msp1_default_mode>;
			status = "okay";
		};

		msp2: msp@80117000 {
			pinctrl-names = "default";
			pinctrl-0 = <&msp2_default_mode>;
		};

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

		prcmu@80157000 {
			ab8500 {
				ab8500-gpio {
				};

				ab8500_usb {
					pinctrl-names = "default", "sleep";
					pinctrl-0 = <&musb_default_mode>;
					pinctrl-1 = <&musb_sleep_mode>;
				};

				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_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";
					};
				};
			};
		};

		mcde@a0350000 {
			pinctrl-names = "default", "sleep";
			pinctrl-0 = <&lcd_default_mode>;
			pinctrl-1 = <&lcd_sleep_mode>;
		};
	};
};
