/dts-v1/;

/include/ "kirkwood.dtsi"
/include/ "kirkwood-6282.dtsi"

/ {
	model = "NETGEAR ReadyNAS Duo v2";
	compatible = "netgear,readynas-duo-v2", "netgear,readynas", "marvell,kirkwood-88f6282", "marvell,kirkwood";

	memory { /* 256 MB */
		device_type = "memory";
		reg = <0x00000000 0x10000000>;
	};

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

	ocp@f1000000 {
		pinctrl: pinctrl@10000 {
			pmx_button_power: pmx-button-power {
				marvell,pins = "mpp47";
				marvell,function = "gpio";
			};
			pmx_button_backup: pmx-button-backup {
				marvell,pins = "mpp45";
				marvell,function = "gpio";
			};
			pmx_button_reset: pmx-button-reset {
				marvell,pins = "mpp13";
				marvell,function = "gpio";
			};
			pmx_led_blue_power: pmx-led-blue-power {
				marvell,pins = "mpp31";
				marvell,function = "gpio";
			};
			pmx_led_blue_activity: pmx-led-blue-activity {
				marvell,pins = "mpp38";
				marvell,function = "gpio";
			};
			pmx_led_blue_disk1: pmx-led-blue-disk1 {
				marvell,pins = "mpp23";
				marvell,function = "gpio";
			};
			pmx_led_blue_disk2: pmx-led-blue-disk2 {
				marvell,pins = "mpp22";
				marvell,function = "gpio";
			};
			pmx_led_blue_backup: pmx-led-blue-backup {
				marvell,pins = "mpp29";
				marvell,function = "gpio";
			};
		};

		i2c@11000 {
			status = "okay";

			rs5c372a: rs5c372a@32 {
				compatible = "ricoh,rs5c372a";
				reg = <0x32>;
			};
		};

		serial@12000 {
			pinctrl-0 = <&pmx_uart0>;
			pinctrl-names = "default";
			status = "okay";
		};

		nand@3000000 {
			status = "okay";

			partition@0 {
				label = "u-boot";
				reg = <0x0000000 0x180000>;
				read-only;
			};

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

			partition@200000 {
				label = "uImage";
				reg = <0x0200000 0x600000>;
			};

			partition@800000 {
				label = "minirootfs";
				reg = <0x0800000 0x1000000>;
			};

			partition@1800000 {
				label = "jffs2";
				reg = <0x1800000 0x6800000>;
			};
		};

		sata@80000 {
			status = "okay";
			nr-ports = <2>;
		};

		pcie-controller {
			status = "okay";

			pcie@1,0 {
				status = "okay";
			};
		};
	};

	gpio-leds {
		compatible = "gpio-leds";
		pinctrl-0 = < &pmx_led_blue_power &pmx_led_blue_activity
			      &pmx_led_blue_disk1 &pmx_led_blue_disk2
			      &pmx_led_blue_backup >;
		pinctrl-names = "default";

		power_led {
			label = "status:blue:power_led";
			gpios = <&gpio0 31 1>;   /* GPIO 31 Active Low */
			linux,default-trigger = "default-on";
		};
		activity_led {
			label = "status:blue:activity_led";
			gpios = <&gpio1 6 1>;    /* GPIO 38 Active Low */
		};
		disk1_led {
			label = "status:blue:disk1_led";
			gpios = <&gpio0 23 1>;   /* GPIO 23 Active Low */
		};
		disk2_led {
			label = "status:blue:disk2_led";
			gpios = <&gpio0 22 1>;   /* GPIO 22 Active Low */
		};
		backup_led {
			label = "status:blue:backup_led";
			gpios = <&gpio0 29 1>;   /* GPIO 29 Active Low*/
		};
	};

	gpio_keys {
		compatible = "gpio-keys";
		#address-cells = <1>;
		#size-cells = <0>;
		pinctrl-0 = <&pmx_button_power &pmx_button_backup
			     &pmx_button_reset>;
		pinctrl-names = "default";

		button@1 {
			label = "Power Button";
			linux,code = <116>;     /* KEY_POWER */
			gpios = <&gpio1 15 1>;
		};
		button@2 {
			label = "Reset Button";
			linux,code = <0x198>;   /* KEY_RESTART */
			gpios = <&gpio0 13 1>;
		};
		button@3 {
			label = "Backup Button";
			linux,code = <133>;     /* KEY_COPY */
			gpios = <&gpio1 13 1>;
		};
	};

        regulators {
                compatible = "simple-bus";
                #address-cells = <1>;
                #size-cells = <0>;

                usb_power: regulator@1 {
                        compatible = "regulator-fixed";
                        reg = <1>;
                        regulator-name = "USB 3.0 Power";
                        regulator-min-microvolt = <5000000>;
                        regulator-max-microvolt = <5000000>;
                        enable-active-high;
                        regulator-always-on;
                        regulator-boot-on;
                        gpio = <&gpio1 14 0>;
                };
        };
};
