/*
 * Device Tree file for Excito Bubba B3
 *
 * Copyright (C) 2013, Andrew Lunn <andrew@lunn.ch>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 *
 * Note: This requires a new'ish version of u-boot, which disables the
 * L2 cache. If your B3 silently fails to boot, u-boot is probably too
 * old. Either upgrade, or consider the following email:
 *
 * http://lists.debian.org/debian-arm/2012/08/msg00128.html
 */

/dts-v1/;

#include "kirkwood.dtsi"
#include "kirkwood-6281.dtsi"

/ {
	model = "Excito B3";
	compatible = "excito,b3", "marvell,kirkwood-88f6281", "marvell,kirkwood";
	memory { /* 512 MB */
		device_type = "memory";
		reg = <0x00000000 0x20000000>;
	};

	chosen {
		bootargs = "console=ttyS0,115200n8 earlyprintk";
	};

	mbus {
		pcie-controller {
			status = "okay";

			/* Wifi model has Atheros chipset on pcie port */
			pcie@1,0 {
				status = "okay";
			};
		};
	};

	ocp@f1000000 {
		pinctrl: pinctrl@10000 {
			pmx_button_power: pmx-button-power {
				marvell,pins = "mpp39";
				marvell,function = "gpio";
			};
			pmx_led_green: pmx-led-green {
				marvell,pins = "mpp38";
				marvell,function = "gpio";
			};
			pmx_led_red: pmx-led-red {
				marvell,pins = "mpp41";
				marvell,function = "gpio";
			};
			pmx_led_blue: pmx-led-blue {
				marvell,pins = "mpp42";
				marvell,function = "gpio";
			};
			pmx_beeper: pmx-beeper {
				marvell,pins = "mpp40";
				marvell,function = "gpio";
			};
		};

		spi@10600 {
			status = "okay";
			pinctrl-0 = <&pmx_spi>;
			pinctrl-names = "default";

			m25p16@0 {
				#address-cells = <1>;
				#size-cells = <1>;
				compatible = "m25p16";
				reg = <0>;
				spi-max-frequency = <40000000>;
				mode = <0>;

				partition@0 {
					reg = <0x0 0xc0000>;
					label = "u-boot";
				};

				partition@c0000 {
					reg = <0xc0000 0x20000>;
					label = "u-boot env";
				};

				partition@e0000 {
					reg = <0xe0000 0x120000>;
					label = "data";
				};
			};
		};

		i2c@11000 {
			status = "okay";
			/*
			 * There is something on the bus at address 0x64.
			 * Not yet identified what it is, maybe the eeprom
			 * for the Atheros WiFi chip?
			 */
		};


		serial@12000 {
			/* Internal on test pins, 3.3v TTL
		 	 * UART0_RX = Testpoint 65
			 * UART0_TX = Testpoint 66
			 * See the Excito Wiki for more details.
		 	 */
			pinctrl-0 = <&pmx_uart0>;
			pinctrl-names = "default";
			status = "okay";
		};

		sata@80000 {
			/* One internal, the second as eSATA */
			status = "okay";
			nr-ports = <2>;
		};
	};

	gpio-leds {
		/*
		 * There is one LED "port" on the front and the colours
		 * mix together giving some interesting combinations.
		 */
		compatible = "gpio-leds";
		pinctrl-0 = < &pmx_led_green &pmx_led_red
			      &pmx_led_blue >;
		pinctrl-names = "default";

		programming_led {
			label = "bubba3:green:programming";
			gpios = <&gpio1 6 GPIO_ACTIVE_HIGH>;
			default-state = "off";
		};

		error_led {
			label = "bubba3:red:error";
			gpios = <&gpio1 9 GPIO_ACTIVE_HIGH>;
		};

		active_led {
			label = "bubba3:blue:active";
			gpios = <&gpio1 10 GPIO_ACTIVE_HIGH>;
		};
	};

	gpio-keys {
		compatible = "gpio-keys";
		pinctrl-0 = <&pmx_button_power>;
		pinctrl-names = "default";

		power-button {
			/* On the back */
			label = "Power Button";
			linux,code = <KEY_POWER>;
			gpios = <&gpio1 7 GPIO_ACTIVE_LOW>;
		};
	};

	beeper: beeper {
		/* 4KHz Piezoelectric buzzer */
		compatible = "gpio-beeper";
		pinctrl-0 = <&pmx_beeper>;
		pinctrl-names = "default";
		gpios = <&gpio1 8 GPIO_ACTIVE_HIGH>;
	};
};

&mdio {
	status = "okay";

	ethphy0: ethernet-phy@8 {
		device_type = "ethernet-phy";
		reg = <8>;
	};

	ethphy1: ethernet-phy@24 {
		device_type = "ethernet-phy";
		reg = <24>;
	};
};

&eth0 {
	status = "okay";
	ethernet0-port@0 {
		phy-handle = <&ethphy0>;
	};
};

&eth1 {
	status = "okay";
	ethernet1-port@0 {
		phy-handle = <&ethphy1>;
	};
};

