/*
 * Hardkernel's Exynos4412 based ODROID-U3 board device tree source
 *
 * Copyright (c) 2014 Marek Szyprowski <m.szyprowski@samsung.com>
 *
 * Device tree source file for Hardkernel's ODROID-U3 board which is based
 * on Samsung's Exynos4412 SoC.
 *
 * 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 "exynos4412-odroid-common.dtsi"

/ {
	model = "Hardkernel ODROID-U3 board based on Exynos4412";
	compatible = "hardkernel,odroid-u3", "samsung,exynos4412", "samsung,exynos4";

	memory {
		reg = <0x40000000 0x7FF00000>;
	};

	leds {
		compatible = "gpio-leds";
		led1 {
			label = "led1:heart";
			gpios = <&gpc1 0 GPIO_ACTIVE_LOW>;
			default-state = "on";
			linux,default-trigger = "heartbeat";
		};
	};

	fan0: pwm-fan {
		compatible = "pwm-fan";
		pwms = <&pwm 0 10000 0>;
		cooling-min-state = <0>;
		cooling-max-state = <3>;
		#cooling-cells = <2>;
		cooling-levels = <0 102 170 230>;
	};

	thermal-zones {
		cpu_thermal: cpu-thermal {
			cooling-maps {
				map0 {
				     trip = <&cpu_alert1>;
				     cooling-device = <&cpu0 7 7>;
				};
				map1 {
				     trip = <&cpu_alert2>;
				     cooling-device = <&cpu0 13 13>;
				};
				map2 {
				     trip = <&cpu_alert0>;
				     cooling-device = <&fan0 0 1>;
				};
				map3 {
				     trip = <&cpu_alert1>;
				     cooling-device = <&fan0 1 2>;
				};
				map4 {
				     trip = <&cpu_alert2>;
				     cooling-device = <&fan0 2 3>;
				};
			};
		};
	};
};

&pwm {
	pinctrl-0 = <&pwm0_out>;
	pinctrl-names = "default";
	samsung,pwm-outputs = <0>;
	status = "okay";
};

&usb3503 {
	clock-names = "refclk";
	clocks = <&pmu_system_controller 0>;
	refclk-frequency = <24000000>;
};

&ehci {
	port@1 {
		status = "okay";
	};
	port@2 {
		status = "okay";
	};
};

&sound {
	simple-audio-card,name = "Odroid-U3";
	simple-audio-card,widgets =
		"Headphone", "Headphone Jack",
		"Speakers", "Speakers";
	simple-audio-card,routing =
		"Headphone Jack", "HPL",
		"Headphone Jack", "HPR",
		"Headphone Jack", "MICBIAS",
		"IN1", "Headphone Jack",
		"Speakers", "SPKL",
		"Speakers", "SPKR";
};

&spi_1 {
	pinctrl-names = "default";
	pinctrl-0 = <&spi1_bus>;
	cs-gpios = <&gpb 5 GPIO_ACTIVE_HIGH>;
	status = "okay";
};
