scripts/dts/python-devicetree/tests/test.dts - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2019, Nordic Semiconductor
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */

 // Used by testedtlib.py

 /dts-v1/;

 / {
 	//
 	// Interrupts
 	//

 	interrupt-parent-test {
 		controller {
 			compatible = "interrupt-three-cell";
 			#interrupt-cells = <3>;
 			interrupt-controller;
 		};

 		node {
 			interrupts = <1 2 3 4 5 6>;
 			interrupt-names = "foo", "bar";
 			interrupt-parent = <&{/interrupt-parent-test/controller}>;
 		};
 	};

 	interrupts-extended-test {
 		controller-0 {
 			compatible = "interrupt-one-cell";
 			#interrupt-cells = <1>;
 			interrupt-controller;
 		};

 		controller-1 {
 			compatible = "interrupt-two-cell";
 			#interrupt-cells = <2>;
 			interrupt-controller;
 		};

 		controller-2 {
 			compatible = "interrupt-three-cell";
 			#interrupt-cells = <3>;
 			interrupt-controller;
 		};

 		node {
 			interrupts-extended = <&{/interrupts-extended-test/controller-0} 1
 					       &{/interrupts-extended-test/controller-1} 2 3
 					       &{/interrupts-extended-test/controller-2} 4 5 6>;
 		};
 	};

 	interrupt-map-test {
 		#address-cells = <2>;
 		#size-cells = <0>;

 		controller-0 {
 			compatible = "interrupt-one-cell";
 			#address-cells = <1>;
 			#interrupt-cells = <1>;
 			interrupt-controller;
 		};

 		controller-1 {
 			compatible = "interrupt-two-cell";
 			#address-cells = <2>;
 			#interrupt-cells = <2>;
 			interrupt-controller;
 		};

 		controller-2 {
 			compatible = "interrupt-three-cell";
 			#address-cells = <3>;
 			#interrupt-cells = <3>;
 			interrupt-controller;
 		};

 		nexus {
 			#interrupt-cells = <2>;
 			interrupt-map = <0 0 0 0 &{/interrupt-map-test/controller-0} 0 0
 					 0 0 0 1 &{/interrupt-map-test/controller-1} 0 0 0 1
 					 0 0 0 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 2
 					 0 1 0 0 &{/interrupt-map-test/controller-0} 0 3
 					 0 1 0 1 &{/interrupt-map-test/controller-1} 0 0 0 4
 					 0 1 0 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 5
 					 0 1 1 0 &{/interrupt-map-no-address/controller} 6>;
 		};

 		empty {
 			#address-cells = <2>;
 			#interrupt-cells = <2>;
 			interrupt-map = <>;
 		};

 		nexus-0 {
 			#address-cells = <0>;
 			#interrupt-cells = <2>;
 			interrupt-map = <0 0 &{/interrupt-map-test/controller-0} 0 0
 					 0 1 &{/interrupt-map-test/controller-1} 0 0 0 1
 					 1 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 2>;
 		};

 		nexus-1 {
 			#address-cells = <1>;
 			#interrupt-cells = <1>;
 			interrupt-map = <4 0 &{/interrupt-map-test/controller-0} 0 3
 					 4 1 &{/interrupt-map-test/controller-1} 0 0 0 4
 					 4 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 5>;
 		};

 		node@0 {
 			reg = <0 0>;
 			interrupts = <0 0 0 1 0 2>;
 			interrupt-parent = <&{/interrupt-map-test/nexus}>;
 		};

 		node@1 {
 			reg = <0 1>;
 			interrupts-extended = <&{/interrupt-map-test/nexus} 0 0
 					       &{/interrupt-map-test/nexus} 0 1
 					       &{/interrupt-map-test/nexus} 0 2>;
 		};

 		node@2 {
 			reg = <0 2>;
 			interrupts = <0 0 0 1 1 2>;
 			interrupt-parent = <&{/interrupt-map-test/nexus-0}>;
 		};

 		node@3 { /* Test the precedence of interrupts/interrupts-extended too */
 			reg = <0 3>;
 			interrupts = <1 2 0 0 0 1>;
 			interrupt-parent = <&{/interrupt-map-test/nexus-0}>;
 			interrupts-extended = <&{/interrupt-map-test/nexus-0} 0 0
 					       &{/interrupt-map-test/nexus-0} 0 1
 					       &{/interrupt-map-test/nexus-0} 1 2>;
 		};

 		node@4 {
 			reg = <0 4>;
 			interrupts = <0 1 2>;
 			interrupt-parent = <&{/interrupt-map-test/nexus-1}>;
 		};

 		node@100000004 {
 			reg = <1 4>;
 			interrupts = <0 1 2>;
 			interrupt-parent = <&{/interrupt-map-test/nexus-1}>;
 		};
 	};

 	interrupt-map-bitops-test {
 		#address-cells = <2>;
 		#size-cells = <0>;

 		controller {
 			compatible = "interrupt-two-cell";
 			#address-cells = <0>;
 			#interrupt-cells = <2>;
 			interrupt-controller;
 		};

 		nexus {
 			#interrupt-cells = <2>;
 			interrupt-map = <6 6 6 6 &{/interrupt-map-bitops-test/controller} 2 1>;
 			interrupt-map-mask = <0xe 0x7 0xe 0x7>;
 			// Not specified in the DT spec., but shows up due to
 			// common code with GPIO. Might as well test it here.
 			interrupt-map-pass-thru = <1 2 3 3>;
 		};

 		// Child unit specifier: 00000007 0000000E 00000007 0000000E
 		// Mask:                 0000000E 00000007 0000000E 00000007
 		// Pass-thru:            00000001 00000002 00000003 00000003
 		node@70000000e {
 			reg = <0x7 0xe>;
 			interrupt-parent = <&{/interrupt-map-bitops-test/nexus}>;
 			interrupts = <0x7 0xe>;
 		};
 	};

 	interrupt-map-no-address {
 		controller {
 			compatible = "interrupt-one-cell";
 			#interrupt-cells = <1>;
 			interrupt-controller;
 		};
 	};

 	//
 	// 'ranges'
 	//

 	ranges-zero-cells {
 		#address-cells = <0>;

 		node {
 			#address-cells = <0>;
 			#size-cells = <0>;

 			ranges;
 		};
 	};

 	ranges-zero-parent-cells {
 		#address-cells = <0>;

 		node {
 			#address-cells = <1>;
 			#size-cells = <0>;

 			ranges = <0xa>,
 				 <0x1a>,
 				 <0x2a>;
 		};
 	};

 	ranges-one-address-cells {
 		#address-cells = <0>;

 		node {
 			reg = <1>;
 			#address-cells = <1>;

 			ranges = <0xa 0xb>,
 				 <0x1a 0x1b>,
 				 <0x2a 0x2b>;
 		};
 	};

 	ranges-one-address-two-size-cells {
 		#address-cells = <0>;

 		node {
 			reg = <1>;
 			#address-cells = <1>;
 			#size-cells = <2>;

 			ranges = <0xa 0xb 0xc>,
 				 <0x1a 0x1b 0x1c>,
 				 <0x2a 0x2b 0x2c>;
 		};
 	};

 	ranges-two-address-cells {
 		#address-cells = <1>;

 		node@1 {
 			reg = <1 2>;

 			ranges = <0xa 0xb 0xc 0xd>,
 				 <0x1a 0x1b 0x1c 0x1d>,
 				 <0x2a 0x2b 0x2c 0x2d>;
 		};
 	};

 	ranges-two-address-two-size-cells {
 		#address-cells = <1>;

 		node@1 {
 			reg = <1 2>;
 			#size-cells = <2>;

 			ranges = <0xa 0xb 0xc 0xd 0xe>,
 				 <0x1a 0x1b 0x1c 0x1d 0x1e>,
 				 <0x2a 0x2b 0x2c 0x2d 0x1d>;
 		};
 	};

 	ranges-three-address-cells {
 		node@1 {
 			reg = <0 1 2>;
 			#address-cells = <3>;

 			ranges = <0xa 0xb 0xc 0xd 0xe 0xf>,
 				 <0x1a 0x1b 0x1c 0x1d 0x1e 0x1f>,
 				 <0x2a 0x2b 0x2c 0x2d 0x2e 0x2f>;
 		};
 	};

 	ranges-three-address-two-size-cells {
 		node@1 {
 			reg = <0 1 2>;
 			#address-cells = <3>;
 			#size-cells = <2>;

 			ranges = <0xa 0xb 0xc 0xd 0xe 0xf 0x10>,
 				 <0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x110>,
 				 <0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x210>;
 		};
 	};

 	//
 	// 'reg'
 	//

 	reg-zero-address-cells {
 		#address-cells = <0>;
 		#size-cells = <1>;

 		node {
 			reg = <1 2>;
 			reg-names = "foo", "bar";
 		};
 	};

 	reg-zero-size-cells {
 		#address-cells = <1>;
 		#size-cells = <0>;

 		node {
 			reg = <1 2>;
 		};
 	};

 	// Use implied #size-cells = <1>
 	reg-ranges {
 		#address-cells = <2>;

 		parent {
 			#address-cells = <1>;
 			ranges = <1 0xa 0xb 1 /* 1    -> 0xA 0xB */
 				  2 0xc 0xd 2 /* 2..3 -> 0xC 0xD */
 				  4 0xe 0xf 1 /* 4    -> 0xE 0xF */ >;

 			node {
 				reg = <5 1 /* Matches no range */
 				       4 1 /* Matches third range */
 				       3 1 /* Matches second range */
 				       2 1 /* Matches second range */
 				       1 1 /* Matches first range */
 				       0 1 /* Matches no range */ >;
 			};
 		};
 	};

 	// Build up <3 2 1> address with nested 'ranges'
 	reg-nested-ranges {
 		#address-cells = <3>;

 		grandparent {
 			#address-cells = <2>;
 			#size-cells = <2>;
 			ranges = <0 0 3 0 0 2 2>;

 			parent {
 				#address-cells = <1>;
 				ranges = <0 2 0 2>;

 				node {
 					reg = <1 1>;
 				};
 			};
 		};
 	};

 	//
 	// 'pinctrl-<index>'
 	//

 	pinctrl {
 		dev {
 			pinctrl-0 = <>;
 			pinctrl-1 = <&{/pinctrl/pincontroller/state-1}>;
 			pinctrl-2 = <&{/pinctrl/pincontroller/state-1}
 				     &{/pinctrl/pincontroller/state-2}>;
 			pinctrl-names = "zero", "one", "two";
 		};

 		pincontroller {
 			state-1 {};

 			state-2 {};
 		};
 	};

 	//
 	// For testing hierarchy.
 	//

 	parent {
 		child-1 {};

 		child-2 {
 			grandchild {};
 		};
 	};

 	//
 	// For testing 'include:'
 	//

 	binding-include {
 		compatible = "binding-include-test";
 		foo = <0>;
 		bar = <1>;
 		baz = <2>;
 		qaz = <3>;

 		child {
 			foo = <0>;
 			bar = <1>;
 			baz = <2>;
 			qaz = <3>;
 		};
 	};

 	//
 	// For testing Node.props (derived from 'properties:' in the binding)
 	//

 	props {
 		compatible = "props";
 		existent-boolean;
 		int = <1>;
 		negative = <(-1)>;
 		negative-array = <(-100) (-10) 0 10 100>;
 		array = <1 2 3>;
 		uint8-array = [12 34];
 		string = "foo";
 		string-array = "foo", "bar", "baz";
 		phandle-ref = <&{/ctrl-1}>;
 		phandle-refs = <&{/ctrl-1} &{/ctrl-2}>;
 		phandle-array-foos = <&{/ctrl-1} 1 &{/ctrl-2} 2 3>;
 		foo-gpios = <&{/ctrl-1} 1>;
 		path = &{/ctrl-1};
 		bar-io-channels = <&{/ctrl-2} 2>;
 	};

 	ctrl-1 {
 		compatible = "phandle-array-controller-1";
 		#phandle-array-foo-cells = <1>;
 		#gpio-cells = <1>;
 	};

 	ctrl-2 {
 		compatible = "phandle-array-controller-2";
 		#phandle-array-foo-cells = <2>;
 		#io-channel-cells = <1>;
 	};

 	props-2 {
 		compatible = "props";
 		phandle-array-foos = <&{/ctrl-0-1} 0 &{/ctrl-0-2}>;
 		phandle-array-foo-names = "a", "missing", "b";
 	};

 	ctrl-0-1 {
 		compatible = "phandle-array-controller-0";
 		#phandle-array-foo-cells = <0>;
 	};

 	ctrl-0-2 {
 		compatible = "phandle-array-controller-0";
 		#phandle-array-foo-cells = <0>;
 	};

 	//
 	// Test <prefix>-map, via gpio-map
 	//

 	gpio-map {
 		source {
 			compatible = "gpio-src";
 			foo-gpios = <&{/gpio-map/connector} 3 4
 				     &{/gpio-map/connector} 1 2>;
 		};

 		connector {
 			#gpio-cells = <2>;
 			// Use different data lengths for source and
 			// destination to make it a bit trickier
 			gpio-map = <1 2 &{/gpio-map/destination} 5
 				    3 4 &{/gpio-map/destination} 6>;
 		};

 		destination {
 			compatible = "gpio-dst";
 			gpio-controller;
 			#gpio-cells = <1>;
 		};
 	};

 	//
 	// For testing Node.props with 'default:' values in binding
 	//

 	defaults {
 		compatible = "defaults";
 		// Should override the 'default:' in the binding
 		default-not-used = <234>;
 	};

 	//
 	// For testing 'enum:'
 	//

 	enums {
 		compatible = "enums";
 		int-enum = <1>;
 		string-enum = "foo_bar";
 		tokenizable-enum = "123 is ok";
 		tokenizable-lower-enum = "bar";
 		array-enum = <0 40 40 10>;
 		string-array-enum = "foo", "bar";
 		no-enum = "baz";
 	};

 	//
 	// For testing 'bus:' and 'on-bus:'
 	//

 	buses {
 		// The 'node' nodes below will map to different bindings since
 		// they appear on different buses
 		foo-bus {
 			compatible = "foo-bus";

 			node1 {
 				compatible = "on-bus", "on-any-bus";

 				nested {
 					compatible = "on-bus";
 				};
 			};

 			node2 {
 				compatible = "on-any-bus", "on-bus";
 			};
 		};

 		bar-bus {
 			compatible = "bar-bus";

 			node {
 				compatible = "on-bus";
 			};
 		};

 		no-bus-node {
 			compatible = "on-any-bus";
 		};
 	};

 	//
 	// Node with 'child-binding:' in binding (along with a recursive
 	// 'child-binding:')
 	//

 	child-binding-dep {};

 	child-binding {
 		compatible = "top-binding";

 		child-1 {
 			child-prop = <1>;

 			grandchild {
 				grandchild-prop = <2>;
 				grandchild-ref = <&{/child-binding-dep}>;
 			};
 		};

 		child-2 {
 			child-prop = <3>;
 			child-ref = <&{/child-binding-dep}>;
 		};
 	};

 	//
 	// zephyr,user binding inference
 	//

 	zephyr,user {
 		boolean;
 		bytes = [81 82 83];
 		number = <23>;
 		numbers = <1>, <2>, <3>;
 		string = "text";
 		strings = "a", "b", "c";
 		handle = <&{/ctrl-1}>;
 		phandles = <&{/ctrl-1}>, <&{/ctrl-2}>;
 		phandle-array-foos = <&{/ctrl-2} 1 2>;
 		foo-gpios = <&{/ctrl-1} 1>;
 		bar-io-channels = <&{/ctrl-2} 2>;
 	};

 	//
 	// For testing that neither 'include: [foo.yaml, bar.yaml]' nor
 	// 'include: [bar.yaml, foo.yaml]' causes errors when one of the files
 	// has 'required: true' and the other 'required: false'
 	//

 	include-order {
 		node-1 {
 			compatible = "order-1";
 			foo = <1>;
 		};

 		node-2 {
 			compatible = "order-2";
 			foo = <2>;
 		};
 	};

 	//
 	// For testing deprecated property
 	//
 	test-deprecated {
 		compatible = "test-deprecated";
 		oldprop = <4>;	/* deprecated property */
 		curprop = <5>;
 	};

 	//
 	// For testing deprecated features
 	//

 	deprecated {
 		compatible = "deprecated";
 		required = <1>;
 		required-2 = <2>;
 		#foo-cells = <2>;

 		sub-node {
 			foos = <&{/deprecated} 1 2>;
 		};
 	};
 };
	/*
	* Copyright (c) 2019, Nordic Semiconductor
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*/

	// Used by testedtlib.py

	/dts-v1/;

	/ {
	//
	// Interrupts
	//

	interrupt-parent-test {
	controller {
	compatible = "interrupt-three-cell";
	#interrupt-cells = <3>;
	interrupt-controller;
	};

	node {
	interrupts = <1 2 3 4 5 6>;
	interrupt-names = "foo", "bar";
	interrupt-parent = <&{/interrupt-parent-test/controller}>;
	};
	};

	interrupts-extended-test {
	controller-0 {
	compatible = "interrupt-one-cell";
	#interrupt-cells = <1>;
	interrupt-controller;
	};

	controller-1 {
	compatible = "interrupt-two-cell";
	#interrupt-cells = <2>;
	interrupt-controller;
	};

	controller-2 {
	compatible = "interrupt-three-cell";
	#interrupt-cells = <3>;
	interrupt-controller;
	};

	node {
	interrupts-extended = <&{/interrupts-extended-test/controller-0} 1
	&{/interrupts-extended-test/controller-1} 2 3
	&{/interrupts-extended-test/controller-2} 4 5 6>;
	};
	};

	interrupt-map-test {
	#address-cells = <2>;
	#size-cells = <0>;

	controller-0 {
	compatible = "interrupt-one-cell";
	#address-cells = <1>;
	#interrupt-cells = <1>;
	interrupt-controller;
	};

	controller-1 {
	compatible = "interrupt-two-cell";
	#address-cells = <2>;
	#interrupt-cells = <2>;
	interrupt-controller;
	};

	controller-2 {
	compatible = "interrupt-three-cell";
	#address-cells = <3>;
	#interrupt-cells = <3>;
	interrupt-controller;
	};

	nexus {
	#interrupt-cells = <2>;
	interrupt-map = <0 0 0 0 &{/interrupt-map-test/controller-0} 0 0
	0 0 0 1 &{/interrupt-map-test/controller-1} 0 0 0 1
	0 0 0 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 2
	0 1 0 0 &{/interrupt-map-test/controller-0} 0 3
	0 1 0 1 &{/interrupt-map-test/controller-1} 0 0 0 4
	0 1 0 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 5
	0 1 1 0 &{/interrupt-map-no-address/controller} 6>;
	};

	empty {
	#address-cells = <2>;
	#interrupt-cells = <2>;
	interrupt-map = <>;
	};

	nexus-0 {
	#address-cells = <0>;
	#interrupt-cells = <2>;
	interrupt-map = <0 0 &{/interrupt-map-test/controller-0} 0 0
	0 1 &{/interrupt-map-test/controller-1} 0 0 0 1
	1 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 2>;
	};

	nexus-1 {
	#address-cells = <1>;
	#interrupt-cells = <1>;
	interrupt-map = <4 0 &{/interrupt-map-test/controller-0} 0 3
	4 1 &{/interrupt-map-test/controller-1} 0 0 0 4
	4 2 &{/interrupt-map-test/controller-2} 0 0 0 0 0 5>;
	};

	node@0 {
	reg = <0 0>;
	interrupts = <0 0 0 1 0 2>;
	interrupt-parent = <&{/interrupt-map-test/nexus}>;
	};

	node@1 {
	reg = <0 1>;
	interrupts-extended = <&{/interrupt-map-test/nexus} 0 0
	&{/interrupt-map-test/nexus} 0 1
	&{/interrupt-map-test/nexus} 0 2>;
	};

	node@2 {
	reg = <0 2>;
	interrupts = <0 0 0 1 1 2>;
	interrupt-parent = <&{/interrupt-map-test/nexus-0}>;
	};

	node@3 { /* Test the precedence of interrupts/interrupts-extended too */
	reg = <0 3>;
	interrupts = <1 2 0 0 0 1>;
	interrupt-parent = <&{/interrupt-map-test/nexus-0}>;
	interrupts-extended = <&{/interrupt-map-test/nexus-0} 0 0
	&{/interrupt-map-test/nexus-0} 0 1
	&{/interrupt-map-test/nexus-0} 1 2>;
	};

	node@4 {
	reg = <0 4>;
	interrupts = <0 1 2>;
	interrupt-parent = <&{/interrupt-map-test/nexus-1}>;
	};

	node@100000004 {
	reg = <1 4>;
	interrupts = <0 1 2>;
	interrupt-parent = <&{/interrupt-map-test/nexus-1}>;
	};
	};

	interrupt-map-bitops-test {
	#address-cells = <2>;
	#size-cells = <0>;

	controller {
	compatible = "interrupt-two-cell";
	#address-cells = <0>;
	#interrupt-cells = <2>;
	interrupt-controller;
	};

	nexus {
	#interrupt-cells = <2>;
	interrupt-map = <6 6 6 6 &{/interrupt-map-bitops-test/controller} 2 1>;
	interrupt-map-mask = <0xe 0x7 0xe 0x7>;
	// Not specified in the DT spec., but shows up due to
	// common code with GPIO. Might as well test it here.
	interrupt-map-pass-thru = <1 2 3 3>;
	};

	// Child unit specifier: 00000007 0000000E 00000007 0000000E
	// Mask: 0000000E 00000007 0000000E 00000007
	// Pass-thru: 00000001 00000002 00000003 00000003
	node@70000000e {
	reg = <0x7 0xe>;
	interrupt-parent = <&{/interrupt-map-bitops-test/nexus}>;
	interrupts = <0x7 0xe>;
	};
	};

	interrupt-map-no-address {
	controller {
	compatible = "interrupt-one-cell";
	#interrupt-cells = <1>;
	interrupt-controller;
	};
	};

	//
	// 'ranges'
	//

	ranges-zero-cells {
	#address-cells = <0>;

	node {
	#address-cells = <0>;
	#size-cells = <0>;

	ranges;
	};
	};

	ranges-zero-parent-cells {
	#address-cells = <0>;

	node {
	#address-cells = <1>;
	#size-cells = <0>;

	ranges = <0xa>,
	<0x1a>,
	<0x2a>;
	};
	};

	ranges-one-address-cells {
	#address-cells = <0>;

	node {
	reg = <1>;
	#address-cells = <1>;

	ranges = <0xa 0xb>,
	<0x1a 0x1b>,
	<0x2a 0x2b>;
	};
	};

	ranges-one-address-two-size-cells {
	#address-cells = <0>;

	node {
	reg = <1>;
	#address-cells = <1>;
	#size-cells = <2>;

	ranges = <0xa 0xb 0xc>,
	<0x1a 0x1b 0x1c>,
	<0x2a 0x2b 0x2c>;
	};
	};

	ranges-two-address-cells {
	#address-cells = <1>;

	node@1 {
	reg = <1 2>;

	ranges = <0xa 0xb 0xc 0xd>,
	<0x1a 0x1b 0x1c 0x1d>,
	<0x2a 0x2b 0x2c 0x2d>;
	};
	};

	ranges-two-address-two-size-cells {
	#address-cells = <1>;

	node@1 {
	reg = <1 2>;
	#size-cells = <2>;

	ranges = <0xa 0xb 0xc 0xd 0xe>,
	<0x1a 0x1b 0x1c 0x1d 0x1e>,
	<0x2a 0x2b 0x2c 0x2d 0x1d>;
	};
	};

	ranges-three-address-cells {
	node@1 {
	reg = <0 1 2>;
	#address-cells = <3>;

	ranges = <0xa 0xb 0xc 0xd 0xe 0xf>,
	<0x1a 0x1b 0x1c 0x1d 0x1e 0x1f>,
	<0x2a 0x2b 0x2c 0x2d 0x2e 0x2f>;
	};
	};

	ranges-three-address-two-size-cells {
	node@1 {
	reg = <0 1 2>;
	#address-cells = <3>;
	#size-cells = <2>;

	ranges = <0xa 0xb 0xc 0xd 0xe 0xf 0x10>,
	<0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x110>,
	<0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x210>;
	};
	};

	//
	// 'reg'
	//

	reg-zero-address-cells {
	#address-cells = <0>;
	#size-cells = <1>;

	node {
	reg = <1 2>;
	reg-names = "foo", "bar";
	};
	};

	reg-zero-size-cells {
	#address-cells = <1>;
	#size-cells = <0>;

	node {
	reg = <1 2>;
	};
	};

	// Use implied #size-cells = <1>
	reg-ranges {
	#address-cells = <2>;

	parent {
	#address-cells = <1>;
	ranges = <1 0xa 0xb 1 /* 1 -> 0xA 0xB */
	2 0xc 0xd 2 /* 2..3 -> 0xC 0xD */
	4 0xe 0xf 1 /* 4 -> 0xE 0xF */ >;

	node {
	reg = <5 1 /* Matches no range */
	4 1 /* Matches third range */
	3 1 /* Matches second range */
	2 1 /* Matches second range */
	1 1 /* Matches first range */
	0 1 /* Matches no range */ >;
	};
	};
	};

	// Build up <3 2 1> address with nested 'ranges'
	reg-nested-ranges {
	#address-cells = <3>;

	grandparent {
	#address-cells = <2>;
	#size-cells = <2>;
	ranges = <0 0 3 0 0 2 2>;

	parent {
	#address-cells = <1>;
	ranges = <0 2 0 2>;

	node {
	reg = <1 1>;
	};
	};
	};
	};

	//
	// 'pinctrl-<index>'
	//

	pinctrl {
	dev {
	pinctrl-0 = <>;
	pinctrl-1 = <&{/pinctrl/pincontroller/state-1}>;
	pinctrl-2 = <&{/pinctrl/pincontroller/state-1}
	&{/pinctrl/pincontroller/state-2}>;
	pinctrl-names = "zero", "one", "two";
	};

	pincontroller {
	state-1 {};

	state-2 {};
	};
	};

	//
	// For testing hierarchy.
	//

	parent {
	child-1 {};

	child-2 {
	grandchild {};
	};
	};

	//
	// For testing 'include:'
	//

	binding-include {
	compatible = "binding-include-test";
	foo = <0>;
	bar = <1>;
	baz = <2>;
	qaz = <3>;

	child {
	foo = <0>;
	bar = <1>;
	baz = <2>;
	qaz = <3>;
	};
	};

	//
	// For testing Node.props (derived from 'properties:' in the binding)
	//

	props {
	compatible = "props";
	existent-boolean;
	int = <1>;
	negative = <(-1)>;
	negative-array = <(-100) (-10) 0 10 100>;
	array = <1 2 3>;
	uint8-array = [12 34];
	string = "foo";
	string-array = "foo", "bar", "baz";
	phandle-ref = <&{/ctrl-1}>;
	phandle-refs = <&{/ctrl-1} &{/ctrl-2}>;
	phandle-array-foos = <&{/ctrl-1} 1 &{/ctrl-2} 2 3>;
	foo-gpios = <&{/ctrl-1} 1>;
	path = &{/ctrl-1};
	bar-io-channels = <&{/ctrl-2} 2>;
	};

	ctrl-1 {
	compatible = "phandle-array-controller-1";
	#phandle-array-foo-cells = <1>;
	#gpio-cells = <1>;
	};

	ctrl-2 {
	compatible = "phandle-array-controller-2";
	#phandle-array-foo-cells = <2>;
	#io-channel-cells = <1>;
	};

	props-2 {
	compatible = "props";
	phandle-array-foos = <&{/ctrl-0-1} 0 &{/ctrl-0-2}>;
	phandle-array-foo-names = "a", "missing", "b";
	};

	ctrl-0-1 {
	compatible = "phandle-array-controller-0";
	#phandle-array-foo-cells = <0>;
	};

	ctrl-0-2 {
	compatible = "phandle-array-controller-0";
	#phandle-array-foo-cells = <0>;
	};

	//
	// Test <prefix>-map, via gpio-map
	//

	gpio-map {
	source {
	compatible = "gpio-src";
	foo-gpios = <&{/gpio-map/connector} 3 4
	&{/gpio-map/connector} 1 2>;
	};

	connector {
	#gpio-cells = <2>;
	// Use different data lengths for source and
	// destination to make it a bit trickier
	gpio-map = <1 2 &{/gpio-map/destination} 5
	3 4 &{/gpio-map/destination} 6>;
	};

	destination {
	compatible = "gpio-dst";
	gpio-controller;
	#gpio-cells = <1>;
	};
	};

	//
	// For testing Node.props with 'default:' values in binding
	//

	defaults {
	compatible = "defaults";
	// Should override the 'default:' in the binding
	default-not-used = <234>;
	};

	//
	// For testing 'enum:'
	//

	enums {
	compatible = "enums";
	int-enum = <1>;
	string-enum = "foo_bar";
	tokenizable-enum = "123 is ok";
	tokenizable-lower-enum = "bar";
	array-enum = <0 40 40 10>;
	string-array-enum = "foo", "bar";
	no-enum = "baz";
	};

	//
	// For testing 'bus:' and 'on-bus:'
	//

	buses {
	// The 'node' nodes below will map to different bindings since
	// they appear on different buses
	foo-bus {
	compatible = "foo-bus";

	node1 {
	compatible = "on-bus", "on-any-bus";

	nested {
	compatible = "on-bus";
	};
	};

	node2 {
	compatible = "on-any-bus", "on-bus";
	};
	};

	bar-bus {
	compatible = "bar-bus";

	node {
	compatible = "on-bus";
	};
	};

	no-bus-node {
	compatible = "on-any-bus";
	};
	};

	//
	// Node with 'child-binding:' in binding (along with a recursive
	// 'child-binding:')
	//

	child-binding-dep {};

	child-binding {
	compatible = "top-binding";

	child-1 {
	child-prop = <1>;

	grandchild {
	grandchild-prop = <2>;
	grandchild-ref = <&{/child-binding-dep}>;
	};
	};

	child-2 {
	child-prop = <3>;
	child-ref = <&{/child-binding-dep}>;
	};
	};

	//
	// zephyr,user binding inference
	//

	zephyr,user {
	boolean;
	bytes = [81 82 83];
	number = <23>;
	numbers = <1>, <2>, <3>;
	string = "text";
	strings = "a", "b", "c";
	handle = <&{/ctrl-1}>;
	phandles = <&{/ctrl-1}>, <&{/ctrl-2}>;
	phandle-array-foos = <&{/ctrl-2} 1 2>;
	foo-gpios = <&{/ctrl-1} 1>;
	bar-io-channels = <&{/ctrl-2} 2>;
	};

	//
	// For testing that neither 'include: [foo.yaml, bar.yaml]' nor
	// 'include: [bar.yaml, foo.yaml]' causes errors when one of the files
	// has 'required: true' and the other 'required: false'
	//

	include-order {
	node-1 {
	compatible = "order-1";
	foo = <1>;
	};

	node-2 {
	compatible = "order-2";
	foo = <2>;
	};
	};

	//
	// For testing deprecated property
	//
	test-deprecated {
	compatible = "test-deprecated";
	oldprop = <4>; /* deprecated property */
	curprop = <5>;
	};

	//
	// For testing deprecated features
	//

	deprecated {
	compatible = "deprecated";
	required = <1>;
	required-2 = <2>;
	#foo-cells = <2>;

	sub-node {
	foos = <&{/deprecated} 1 2>;
	};
	};
	};