/*
 * Copyright (c) 2019 SEAL AG
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/dts-v1/;

#include <mem.h>
#include <nxp/MK82FN256VLL15.dtsi>
#include <dt-bindings/pwm/pwm.h>

/ {
	model = "NXP Kinetis K82 Freedom Board";
	compatible = "nxp,mk82f25615", "nxp,k82f", "nxp,k8x";

	aliases {
		led0 = &red_led;
		led1 = &green_led;
		led2 = &blue_led;
		pwm-led0 = &red_pwm_led;
		pwm-led1 = &green_pwm_led;
		pwm-led2 = &blue_pwm_led;
		sw0 = &user_button_0;
		sw1 = &user_button_1;
	};

	chosen {
		zephyr,sram = &sram0;
		zephyr,flash = &flash0;
		zephyr,code-partition = &slot0_partition;
		zephyr,console = &lpuart4;
		zephyr,shell-uart = &lpuart4;
		zephyr,uart-pipe = &lpuart4;
	};

	leds {
		compatible = "gpio-leds";
		red_led: led_0 {
			gpios = <&gpioc 8 0>;
			label = "User LED D3 Red";
		};
		green_led: led_1 {
			gpios = <&gpioc 9 0>;
			label = "User LED D3 Green";
		};
		blue_led: led_2 {
			gpios = <&gpioc 10 0>;
			label = "User LED D3 Blue";
		};
	};

	pwmleds {
		compatible = "pwm-leds";

		red_pwm_led: red_pwm_led {
			pwms = <&ftm3 4 15625000 PWM_POLARITY_INVERTED>;
		};
		green_pwm_led: green_pwm_led {
			pwms = <&ftm3 5 15625000 PWM_POLARITY_INVERTED>;
		};
		blue_pwm_led: blue_pwm_led {
			pwms = <&ftm3 6 15625000 PWM_POLARITY_INVERTED>;
		};
	};

	gpio_keys {
		compatible = "gpio-keys";
		user_button_0: button_0 {
			label = "User SW2";
			gpios = <&gpioa 4 GPIO_ACTIVE_LOW>;
		};
		user_button_1: button_1 {
			label = "User SW3";
			gpios = <&gpioc 6 GPIO_ACTIVE_LOW>;
		};
	};

	arduino_header: connector {
		compatible = "arduino-header-r3";
		#gpio-cells = <2>;
		gpio-map-mask = <0xffffffff 0xffffffc0>;
		gpio-map-pass-thru = <0 0x3f>;
		gpio-map = <0 0 &gpiob 0 0>,	/* A0 */
			   <1 0 &gpiob 1 0>,	/* A1 */
			   <2 0 &gpioc 1 0>,	/* A2 */
			   <3 0 &gpioc 2 0>,	/* A3 */
			   <4 0 &gpiob 3 0>,	/* A4 */
			   <5 0 &gpiob 2 0>,	/* A5 */
			   <6 0 &gpiob 16 0>,	/* D0 */
			   <7 0 &gpiob 17 0>,	/* D1 */
			   <8 0 &gpioc 12 0>,	/* D2 */
			   <9 0 &gpiod 0 0>,	/* D3 */
			   <10 0 &gpioc 11 0>,	/* D4 */
			   <11 0 &gpioc 10 0>,	/* D5 */
			   <12 0 &gpioc 8 0>,	/* D6 */
			   <13 0 &gpioc 9 0>,	/* D7 */
			   <14 0 &gpioc 3 0>,	/* D8 */
			   <15 0 &gpioc 5 0>,	/* D9 */
			   <16 0 &gpiod 4 0>,	/* D10 */
			   <17 0 &gpiod 2 0>,	/* D11 */
			   <18 0 &gpiod 3 0>,	/* D12 */
			   <19 0 &gpiod 1 0>,	/* D13 */
			   <20 0 &gpioa 1 0>,	/* D14 */
			   <21 0 &gpioa 2 0>;	/* D15 */
	};
};

&sim {
	pllfll-select = <KINETIS_SIM_PLLFLLSEL_MCGPLLCLK>;
	er32k-select = <KINETIS_SIM_ER32KSEL_OSC32KCLK>;
};

&adc0 {
	status = "okay";
	pinctrl-0 = <&ADC0_SE15_PTC1>;
};

&gpioa {
	status = "okay";
};

&gpiob {
	status = "okay";
};

&gpioc {
	status = "okay";
};

&gpiod {
	status = "okay";
};

&gpioe {
	status = "okay";
};

&flash0 {

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

		boot_partition: partition@0 {
			label = "mcuboot";
			reg = <0x0 DT_SIZE_K(48)>;
		};
		storage_partition: partition@c000 {
			label = "storage";
			reg = <0xc000 DT_SIZE_K(32)>;
		};
		slot0_partition: partition@14000 {
			label = "image-0";
			reg = <0x14000 DT_SIZE_K(80)>;
		};
		slot1_partition: partition@28000 {
			label = "image-1";
			reg = <0x28000 DT_SIZE_K(80)>;
		};
		scratch_partition: partition@3c000 {
			label = "image-scratch";
			reg = <0x3c000 DT_SIZE_K(16)>;
		};
	};
};

&i2c3 {
	status = "okay";
	pinctrl-0 = <&I2C3_SDA_PTA1 &I2C3_SCL_PTA2>;

	fxos8700@1c {
		compatible = "nxp,fxos8700";
		reg = <0x1c>;
		label = "FXOS8700";
		int1-gpios = <&gpioc 13 GPIO_ACTIVE_LOW>;
	};
};

&I2C3_SDA_PTA1 {
	drive-open-drain;
};

&I2C3_SCL_PTA2 {
	drive-open-drain;
};

&lpuart4 {
	status = "okay";
	pinctrl-0 = <&LPUART4_RX_PTC14 &LPUART4_TX_PTC15>;
	current-speed = <115200>;
};

&ftm3 {
	status = "okay";
	compatible = "nxp,kinetis-ftm-pwm";
	#pwm-cells = <3>;
	pinctrl-0 = <&FTM3_CH4_PTC8 &FTM3_CH5_PTC9 &FTM3_CH6_PTC10>;
};

&spi1 {
	status = "okay";

	pinctrl-0 = <&SPI1_SCK_PTE1 &SPI1_SOUT_PTE2
		     &SPI1_SIN_PTE4 &SPI1_PCS0_PTE5>;

	mx25u32: mx25u3235f@0 {
		compatible = "jedec,spi-nor";
		label = "MX25U3235F";
		reg = <0>;
		spi-max-frequency = <104000000>;
		wp-gpios = <&gpioe 3 0>;
		reset-gpios = <&gpioe 0 0>;
		size = <0x2000000>;
		jedec-id = [c2 25 36];
	};
};

&usbotg {
	status = "okay";
};

&edma0 {
	status = "okay";
};

&adc0 {
	status = "okay";
};

&pit0 {
	status = "okay";
};
