/*
 * Broadcom BCM470X / BCM5301X ARM platform code.
 * DTS for Buffalo WZR-600DHP2
 *
 * Copyright (C) 2014 Rafał Miłecki <zajec5@gmail.com>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/dts-v1/;

#include "bcm47081.dtsi"
#include "bcm5301x-nand-cs0-bch8.dtsi"

/ {
	compatible = "buffalo,wzr-600dhp2", "brcm,bcm47081", "brcm,bcm4708";
	model = "Buffalo WZR-600DHP2 (BCM47081)";

	chosen {
		bootargs = "console=ttyS0,115200 earlycon";
	};

	memory {
		reg = <0x00000000 0x08000000
		       0x88000000 0x08000000>;
	};

	spi {
		compatible = "spi-gpio";
		num-chipselects = <1>;
		gpio-sck = <&chipcommon 7 0>;
		gpio-mosi = <&chipcommon 4 0>;
		cs-gpios = <&chipcommon 6 0>;
		#address-cells = <1>;
		#size-cells = <0>;

		hc595: gpio_spi@0 {
			compatible = "fairchild,74hc595";
			reg = <0>;
			registers-number = <1>;
			spi-max-frequency = <100000>;

			gpio-controller;
			#gpio-cells = <2>;

		};
	};

	leds {
		compatible = "gpio-leds";

		power0 {
			label = "bcm53xx:green:power";
			gpios = <&hc595 1 GPIO_ACTIVE_HIGH>;
			linux,default-trigger = "default-on";
		};

		power1 {
			label = "bcm53xx:red:power";
			gpios = <&hc595 2 GPIO_ACTIVE_HIGH>;
		};

		router0 {
			label = "bcm53xx:green:router";
			gpios = <&hc595 3 GPIO_ACTIVE_HIGH>;
			linux,default-trigger = "default-on";
		};

		router1 {
			label = "bcm53xx:amber:router";
			gpios = <&hc595 4 GPIO_ACTIVE_HIGH>;
		};

		wan {
			label = "bcm53xx:green:wan";
			gpios = <&hc595 5 GPIO_ACTIVE_HIGH>;
			linux,default-trigger = "default-on";
		};

		wireless0 {
			label = "bcm53xx:green:wireless";
			gpios = <&hc595 6 GPIO_ACTIVE_HIGH>;
		};

		wireless1 {
			label = "bcm53xx:amber:wireless";
			gpios = <&hc595 7 GPIO_ACTIVE_HIGH>;
		};
	};

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

		aoss {
			label = "AOSS";
			linux,code = <KEY_WPS_BUTTON>;
			gpios = <&chipcommon 9 GPIO_ACTIVE_LOW>;
		};

		restart {
			label = "Reset";
			linux,code = <KEY_RESTART>;
			gpios = <&chipcommon 11 GPIO_ACTIVE_LOW>;
		};

		/* Switch device mode? */
		mode {
			label = "Mode";
			linux,code = <KEY_SETUP>;
			gpios = <&chipcommon 14 GPIO_ACTIVE_LOW>;
		};

		eject {
			label = "USB eject";
			linux,code = <KEY_EJECTCD>;
			gpios = <&chipcommon 15 GPIO_ACTIVE_LOW>;
		};
	};
};
