mirror of
https://github.com/zephyrproject-rtos/zephyr
synced 2025-08-03 02:25:04 +00:00
b6dc0a24f7
Add enum_tokenizable and enum_upper_tokenizable to PropertySpec. These allow a PropertySpec to declare that it both has an enumeration of values and all of them are strings which are "tokenizable". Don't bother extending Property with these; the user can access the information through Property.spec now, so the extra delegation is unnecessary. See the docstrings for details on what "tokenizable" means. The basic idea is that we should be able to use the DT binding's enum values as C 'enum' enumerators in a "reasonable way". Add val_as_token to Property. This produces a canonical token for the property value. Add tests for this feature in particular and property enumerations in general. Signed-off-by: Martí Bolívar <marti.bolivar@nordicsemi.no>
426 lines
8.1 KiB
Plaintext
426 lines
8.1 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>;
|
|
};
|
|
};
|
|
|
|
//
|
|
// '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>;
|
|
};
|
|
};
|
|
};
|
|
};
|
|
|
|
//
|
|
// '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 Node.parent and Node.children
|
|
//
|
|
|
|
parent {
|
|
child-1 {
|
|
};
|
|
child-2 {
|
|
grandchild {
|
|
};
|
|
};
|
|
};
|
|
|
|
//
|
|
// For testing 'include:'
|
|
//
|
|
|
|
binding-include {
|
|
compatible = "binding-include-test";
|
|
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>;
|
|
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};
|
|
};
|
|
|
|
|
|
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>;
|
|
};
|
|
|
|
props-2 {
|
|
compatible = "props";
|
|
phandle-array-foos = < &{/ctrl-0-1} &{/ctrl-0-2} >;
|
|
};
|
|
|
|
|
|
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";
|
|
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";
|
|
node {
|
|
compatible = "on-bus";
|
|
nested {
|
|
compatible = "on-bus";
|
|
};
|
|
};
|
|
};
|
|
bar-bus {
|
|
compatible = "bar-bus";
|
|
node {
|
|
compatible = "on-bus";
|
|
};
|
|
};
|
|
};
|
|
|
|
//
|
|
// Node with 'child-binding:' in binding (along with a recursive
|
|
// 'child-binding:')
|
|
//
|
|
|
|
child-binding {
|
|
compatible = "child-binding";
|
|
child-1 {
|
|
child-prop = <1>;
|
|
grandchild {
|
|
grandchild-prop = <2>;
|
|
};
|
|
};
|
|
child-2 {
|
|
child-prop = <3>;
|
|
};
|
|
};
|
|
|
|
//
|
|
// 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>;
|
|
};
|
|
|
|
//
|
|
// 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>;
|
|
};
|
|
};
|
|
};
|