| /* |
| * 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>; |
| }; |
| 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>; |
| }; |
| }; |
| 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>; |
| }; |
| }; |
| |
| // |
| // GPIOS |
| // |
| |
| gpio-test { |
| controller-1 { |
| compatible = "gpio-two-cell"; |
| #gpio-cells = <2>; |
| gpio-controller; |
| }; |
| node { |
| gpios = <&{/gpio-test/controller-0} 1 |
| &{/gpio-test/controller-1} 2 3>; |
| foo-gpios = <&{/gpio-test/controller-1} 4 5>; |
| bar-gpios = <&{/gpio-test/controller-1} 6 7>; |
| }; |
| // Putting this controller last gives us some coverage for ordering |
| // issues during initialization |
| controller-0 { |
| compatible = "gpio-one-cell"; |
| #gpio-cells = <1>; |
| gpio-controller; |
| }; |
| }; |
| |
| // |
| // Clocks |
| // |
| |
| clock-test { |
| fixed-clock { |
| // 'fixed-clock' is currently special-cased in the code |
| compatible = "fixed-clock"; |
| #clock-cells = <0>; |
| clock-frequency = <123>; |
| }; |
| clock-1 { |
| compatible = "clock-one-cell"; |
| #clock-cells = <1>; |
| }; |
| clock-2 { |
| compatible = "clock-two-cell"; |
| #clock-cells = <2>; |
| }; |
| node { |
| clocks = <&{/clock-test/fixed-clock} |
| &{/clock-test/clock-1} 1 |
| &{/clock-test/clock-2} 1 2>; |
| clock-names = "fixed", "one-cell", "two-cell"; |
| }; |
| }; |
| |
| // |
| // PWMs |
| // |
| |
| pwm-test { |
| pwm-0 { |
| compatible = "pwm-zero-cell"; |
| #pwm-cells = <0>; |
| }; |
| pwm-1 { |
| compatible = "pwm-one-cell"; |
| #pwm-cells = <1>; |
| }; |
| node { |
| pwms = <&{/pwm-test/pwm-0} |
| &{/pwm-test/pwm-1} 1>; |
| pwm-names = "zero-cell", "one-cell"; |
| }; |
| }; |
| |
| // |
| // IO channels |
| // |
| |
| // Lots of common code with PWMs and clocks, so just test the basics |
| io-channel-test { |
| io-channel { |
| compatible = "io-channel"; |
| #io-channel-cells = <1>; |
| }; |
| node { |
| io-channels = <&{/io-channel-test/io-channel} 1>; |
| io-channel-names = "io-channel"; |
| }; |
| }; |
| |
| // |
| // 'reg' |
| // |
| |
| reg-zero-address-cells { |
| #address-cells = <0>; |
| #size-cells = <1>; |
| |
| node { |
| reg = <1 2>; |
| }; |
| }; |
| 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>; |
| }; |
| }; |
| }; |
| }; |
| |
| // |
| // For testing 'include:' |
| // |
| |
| binding-include { |
| compatible = "binding-include-test"; |
| foo = <0>; |
| bar = <1>; |
| baz = <2>; |
| qaz = <3>; |
| }; |
| |
| // |
| // For testing Device.props (derived from 'properties:' in the binding) |
| // |
| |
| props { |
| compatible = "props"; |
| existent-boolean; |
| int = <1>; |
| array = <1 2 3>; |
| uint8-array = [ 12 34 ]; |
| string = "foo"; |
| string-array = "foo", "bar", "baz"; |
| phandle-ref = < &{/props/node} >; |
| phandle-refs = < &{/props/node} &{/props/node2} >; |
| phandle-refs-and-vals = < &{/props/node} 1 &{/props/node2} 2 >; |
| // Does not appear in the binding, so won't create an entry in |
| // Device.props |
| not-speced = <0>; |
| |
| node { |
| }; |
| |
| node2 { |
| }; |
| }; |
| |
| // |
| // Parent with 'sub-node:' in binding |
| // |
| |
| parent-with-sub-node { |
| compatible = "parent-with-sub-node"; |
| node { |
| foo = <1>; |
| bar = <2>; |
| not-speced = <0>; |
| }; |
| }; |
| |
| // |
| // For testing deprecated features |
| // |
| |
| deprecated { |
| compatible = "deprecated"; |
| required = <1>; |
| required-2 = <2>; |
| }; |
| }; |
