// 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: 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: push-button-pins {
		pinctrl-single,pins = <
			AM33XX_PADCONF(AM335X_PIN_LCD_HSYNC, PIN_INPUT_PULLDOWN, MUX_MODE7)	/* lcd_hsync.gpio2_23 */
		>;
	};

	uart0_pins: 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-pins {
		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: 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: spi0-pins {
		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_sw {
	pinctrl-names = "default";
	pinctrl-0 = <&cpsw_default>;
	status = "okay";
};

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

&cpsw_port1 {
	ti,dual-emac-pvid = <1>;
};

&cpsw_port2 {
	ti,dual-emac-pvid = <2>;
};

&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>;

	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>;

	flash@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@0 {
		compatible = "tcg,tpm_tis-spi";
		reg = <0>;
		spi-max-frequency = <500000>;
	};
};
