/*
 * Copyright (C) 2011 Texas Instruments Incorporated - http://www.ti.com/
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
/dts-v1/;

/include/ "omap4.dtsi"

/ {
	model = "TI OMAP4 PandaBoard";
	compatible = "ti,omap4-panda", "ti,omap4430", "ti,omap4";

	memory {
		device_type = "memory";
		reg = <0x80000000 0x40000000>; /* 1 GB */
	};

	leds {
		compatible = "gpio-leds";
		heartbeat {
			label = "pandaboard::status1";
			gpios = <&gpio1 7 0>;
			linux,default-trigger = "heartbeat";
		};

		mmc {
			label = "pandaboard::status2";
			gpios = <&gpio1 8 0>;
			linux,default-trigger = "mmc0";
		};
	};
};

&i2c1 {
	clock-frequency = <400000>;

	twl: twl@48 {
		reg = <0x48>;
		/* SPI = 0, IRQ# = 7, 4 = active high level-sensitive */
		interrupts = <0 7 4>; /* IRQ_SYS_1N cascaded to gic */
		interrupt-parent = <&gic>;
	};
};

/include/ "twl6030.dtsi"

&i2c2 {
	clock-frequency = <400000>;
};

&i2c3 {
	clock-frequency = <100000>;

	/*
	 * Display monitor features are burnt in their EEPROM as EDID data.
	 * The EEPROM is connected as I2C slave device.
	 */
	eeprom@50 {
		compatible = "ti,eeprom";
		reg = <0x50>;
	};
};

&i2c4 {
	clock-frequency = <400000>;
};

&mmc1 {
	vmmc-supply = <&vmmc>;
	ti,bus-width = <8>;
};

&mmc2 {
	status = "disable";
};

&mmc3 {
	status = "disable";
};

&mmc4 {
	status = "disable";
};

&mmc5 {
	ti,non-removable;
	ti,bus-width = <4>;
};
