343 lines
6.7 KiB
Plaintext
343 lines
6.7 KiB
Plaintext
/*
|
|
* 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 >;
|
|
|
|
node {
|
|
};
|
|
|
|
node2 {
|
|
};
|
|
};
|
|
|
|
//
|
|
// For testing Device.props with 'default:' values in binding
|
|
//
|
|
|
|
defaults {
|
|
compatible = "defaults";
|
|
// Should override the 'default:' in the binding
|
|
default-not-used = <234>;
|
|
};
|
|
|
|
//
|
|
// Parent with 'sub-node:' in binding
|
|
//
|
|
|
|
parent-with-sub-node {
|
|
compatible = "parent-with-sub-node";
|
|
node {
|
|
foo = <1>;
|
|
bar = <2>;
|
|
};
|
|
};
|
|
|
|
//
|
|
// For testing deprecated features
|
|
//
|
|
|
|
deprecated {
|
|
compatible = "deprecated";
|
|
required = <1>;
|
|
required-2 = <2>;
|
|
};
|
|
};
|