// SPDX-License-Identifier: GPL-2.0-or-later OR MIT
/*
 * Copyright 2014-2022 Toradex
 * Copyright 2012 Freescale Semiconductor, Inc.
 * Copyright 2011 Linaro Ltd.
 */

/dts-v1/;

#include <dt-bindings/gpio/gpio.h>
#include <dt-bindings/input/input.h>
#include <dt-bindings/interrupt-controller/irq.h>
#include "imx6q.dtsi"
#include "imx6qdl-apalis.dtsi"

/ {
	model = "Toradex Apalis iMX6Q/D Module on Ixora Carrier Board";
	compatible = "toradex,apalis_imx6q-ixora", "toradex,apalis_imx6q",
		     "fsl,imx6q";

	aliases {
		i2c0 = &i2c1;
		i2c1 = &i2c3;
		i2c2 = &i2c2;
		rtc0 = &rtc_i2c;
		rtc1 = &snvs_rtc;
	};

	chosen {
		stdout-path = "serial0:115200n8";
	};

	leds {
		compatible = "gpio-leds";
		pinctrl-names = "default";
		pinctrl-0 = <&pinctrl_leds_ixora>;

		led4-green {
			gpios = <&gpio1 17 GPIO_ACTIVE_HIGH>;
			label = "LED_4_GREEN";
		};

		led4-red {
			gpios = <&gpio1 21 GPIO_ACTIVE_HIGH>;
			label = "LED_4_RED";
		};

		led5-green {
			gpios = <&gpio2 1 GPIO_ACTIVE_HIGH>;
			label = "LED_5_GREEN";
		};

		led5-red {
			gpios = <&gpio2 2 GPIO_ACTIVE_HIGH>;
			label = "LED_5_RED";
		};
	};
};

&can1 {
	status = "okay";
};

&can2 {
	status = "okay";
};

/* I2C1_SDA/SCL on MXM3 209/211 (e.g. RTC on carrier board) */
&i2c1 {
	status = "okay";

	eeprom@50 {
		compatible = "atmel,24c02";
		reg = <0x50>;
	};

	/* M41T0M6 real time clock on carrier board */
	rtc_i2c: rtc@68 {
		compatible = "st,m41t0";
		reg = <0x68>;
	};
};

/*
 * I2C3_SDA/SCL (CAM) on MXM3 pin 201/203 (e.g. camera sensor on carrier
 * board)
 */
&i2c3 {
	status = "okay";
};

&pcie {
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_reset_moci>;
	/* active-high meaning opposite of regular PERST# active-low polarity */
	reset-gpio = <&gpio1 28 GPIO_ACTIVE_HIGH>;
	reset-gpio-active-high;
	status = "okay";
};

&pwm1 {
	status = "okay";
};

&pwm2 {
	status = "okay";
};

&pwm3 {
	status = "okay";
};

&pwm4 {
	status = "okay";
};

&reg_usb_host_vbus {
	status = "okay";
};

&reg_usb_otg_vbus {
	status = "okay";
};

&sata {
	status = "okay";
};

&sound_spdif {
	status = "okay";
};

&spdif {
	status = "okay";
};

&uart1 {
	status = "okay";
};

&uart2 {
	status = "okay";
};

&uart4 {
	status = "okay";
};

&uart5 {
	status = "okay";
};

&usbh1 {
	disable-over-current;
	vbus-supply = <&reg_usb_host_vbus>;
	status = "okay";
};

&usbotg {
	disable-over-current;
	vbus-supply = <&reg_usb_otg_vbus>;
	status = "okay";
};

/* SD1 */
&usdhc2 {
	cd-gpios = <&gpio6 14 GPIO_ACTIVE_LOW>;
	pinctrl-names = "default";
	pinctrl-0 = <&pinctrl_usdhc2 &pinctrl_sd_cd>;
	status = "okay";
};

&iomuxc {
	pinctrl_leds_ixora: ledsixoragrp {
		fsl,pins = <
			MX6QDL_PAD_SD1_DAT1__GPIO1_IO17 0x1b0b0
			MX6QDL_PAD_SD1_DAT3__GPIO1_IO21 0x1b0b0
			MX6QDL_PAD_NANDF_D1__GPIO2_IO01 0x1b0b0
			MX6QDL_PAD_NANDF_D2__GPIO2_IO02 0x1b0b0
		>;
	};
};
