// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2018 MOXA Inc. - https://www.moxa.com/
 *
 * Authors: SZ Lin (林上智) <sz.lin@moxa.com>
 *          Wes Huang (黃淵河) <wes.huang@moxa.com>
 *          Fero JD Zhou (周俊達) <FeroJD.Zhou@moxa.com>
 */

#include "am33xx.dtsi"

/ {
	vbat: vbat-regulator {
		compatible = "regulator-fixed";
	};

	/* Power supply provides a fixed 3.3V @3A */
	vmmcsd_fixed: vmmcsd-regulator {
	      compatible = "regulator-fixed";
	      regulator-name = "vmmcsd_fixed";
	      regulator-min-microvolt = <3300000>;
	      regulator-max-microvolt = <3300000>;
	      regulator-boot-on;
	};

	buttons: push_button {
		compatible = "gpio-keys";
	};
};

&am33xx_pinmux {
	pinctrl-names = "default";

	i2c0_pins: pinmux_i2c0_pins {
		pinctrl-single,pins = <
			AM33XX_PADCONF(AM335X_PIN_I2C0_SDA, PIN_INPUT_PULLUP, MUX_MODE0)
			AM33XX_PADCONF(AM335X_PIN_I2C0_SCL, PIN_INPUT_PULLUP, MUX_MODE0)
		>;
	};

	push_button_pins: pinmux_push_button {
		pinctrl-single,pins = <
			AM33XX_PADCONF(AM335X_PIN_LCD_HSYNC, PIN_INPUT_PULLDOWN, MUX_MODE7)	/* lcd_hsync.gpio2_23 */
		>;
	};

	uart0_pins: pinmux_uart0_pins {
		pinctrl-single,pins = <
			AM33XX_PADCONF(AM335X_PIN_UART0_RXD, PIN_INPUT_PULLUP, MUX_MODE0)
			AM33XX_PADCONF(AM335X_PIN_UART0_TXD, PIN_OUTPUT_PULLDOWN, MUX_MODE0)
		>;
	};

	davinci_mdio_default: davinci_mdio_default {
		pinctrl-single,pins = <
			/* MDIO */
			AM33XX_PADCONF(AM335X_PIN_MDIO, PIN_INPUT_PULLUP | SLEWCTRL_FAST, MUX_MODE0)
			AM33XX_PADCONF(AM335X_PIN_MDC, PIN_OUTPUT_PULLUP, MUX_MODE0)
		>;
	};

	mmc1_pins_default: pinmux_mmc1_pins {
		pinctrl-single,pins = <
			/* eMMC */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD0, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad12.mmc1_dat0 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD1, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad13.mmc1_dat1 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD2, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad14.mmc1_dat2 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD3, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad15.mmc1_dat3 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD4, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad8.mmc1_dat4 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD5, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad9.mmc1_dat5 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD6, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad10.mmc1_dat6 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_AD7, PIN_INPUT_PULLUP, MUX_MODE1)	/* gpmc_ad11.mmc1_dat7 */
			AM33XX_PADCONF(AM335X_PIN_GPMC_CSN2, PIN_INPUT_PULLUP, MUX_MODE2)	/* gpmc_csn2.mmc1_cmd */
			AM33XX_PADCONF(AM335X_PIN_GPMC_CSN1, PIN_INPUT_PULLUP, MUX_MODE2)	/* gpmc_csn1.mmc1_clk */
		>;
	};

	spi0_pins: pinmux_spi0 {
		pinctrl-single,pins = <
			AM33XX_PADCONF(AM335X_PIN_SPI0_SCLK, PIN_INPUT_PULLUP, MUX_MODE0)
			AM33XX_PADCONF(AM335X_PIN_SPI0_CS0, PIN_INPUT_PULLUP, MUX_MODE0)
			AM33XX_PADCONF(AM335X_PIN_SPI0_D0, PIN_INPUT_PULLUP, MUX_MODE0)
			AM33XX_PADCONF(AM335X_PIN_SPI0_D1, PIN_INPUT_PULLUP, MUX_MODE0)
		>;
	};
};

&uart0 {
	/* Console */
	status = "okay";
	pinctrl-names = "default";
	pinctrl-0 = <&uart0_pins>;
};

&i2c0 {
	pinctrl-names = "default";
	pinctrl-0 = <&i2c0_pins>;

	status = "okay";
	clock-frequency = <400000>;

	eeprom: eeprom@50 {
		compatible = "atmel,24c16";
		pagesize = <16>;
		reg = <0x50>;
	};

	rtc_wdt: rtc_wdt@68 {
		compatible = "dallas,ds1374";
		reg = <0x68>;
	};
};

&usb0 {
	dr_mode = "host";
};

/* Power */
&vbat {
	regulator-name = "vbat";
	regulator-min-microvolt = <5000000>;
	regulator-max-microvolt = <5000000>;
};

&mac {
	pinctrl-names = "default";
	pinctrl-0 = <&cpsw_default>;
	status = "okay";
};

&davinci_mdio {
	pinctrl-names = "default";
	pinctrl-0 = <&davinci_mdio_default>;
	status = "okay";
};

&cpsw_emac0 {
	status = "okay";
};

&cpsw_emac1 {
	status = "okay";
};

&sham {
	status = "okay";
};

&aes {
	status = "okay";
};

&gpio0_target {
	ti,no-reset-on-init;
};

&mmc2 {
	pinctrl-names = "default";
	vmmc-supply = <&vmmcsd_fixed>;
	bus-width = <8>;
	pinctrl-0 = <&mmc1_pins_default>;
	non-removable;
	status = "okay";
};

&buttons {
	pinctrl-names = "default";
	pinctrl-0 = <&push_button_pins>;
	#address-cells = <1>;
	#size-cells = <0>;

	button@0 {
		label = "push_button";
		linux,code = <0x100>;
		gpios = <&gpio2 23 GPIO_ACTIVE_LOW>;
	};
};

/* SPI Busses */
&spi0 {
	status = "okay";
	pinctrl-names = "default";
	pinctrl-0 = <&spi0_pins>;

	m25p80@0 {
		compatible = "mx25l6405d";
		spi-max-frequency = <40000000>;

		reg = <0>;
		spi-cpol;
		spi-cpha;

		partitions {
			compatible = "fixed-partitions";
			#address-cells = <1>;
			#size-cells = <1>;

			/* reg : The partition's offset and size within the mtd bank. */
			partitions@0 {
				label = "MLO";
				reg = <0x0 0x80000>;
			};

			partitions@1 {
				label = "U-Boot";
				reg = <0x80000 0x100000>;
			};

			partitions@2 {
				label = "U-Boot Env";
				reg = <0x180000 0x40000>;
			};
		};
	};
};

&spi1 {
	status = "okay";
	pinctrl-names = "default";
	pinctrl-0 = <&spi1_pins>;

	tpm_spi_tis@0 {
		compatible = "tcg,tpm_tis-spi";
		reg = <0>;
		spi-max-frequency = <500000>;
	};
};
