2021-08-19 03:40:25 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
/*
|
|
|
|
* Devicetree file for running sandbox tests
|
|
|
|
*
|
|
|
|
* This includes lots of extra devices used by various tests.
|
|
|
|
*
|
|
|
|
* Note that SPL use the main sandbox.dts file
|
|
|
|
*/
|
|
|
|
|
2014-02-26 22:59:21 +00:00
|
|
|
/dts-v1/;
|
|
|
|
|
2020-01-13 10:35:13 +00:00
|
|
|
#include <dt-bindings/gpio/gpio.h>
|
|
|
|
#include <dt-bindings/gpio/sandbox-gpio.h>
|
2021-02-18 10:33:18 +00:00
|
|
|
#include <dt-bindings/input/input.h>
|
2020-09-14 15:01:57 +00:00
|
|
|
#include <dt-bindings/pinctrl/sandbox-pinmux.h>
|
2020-10-16 10:46:34 +00:00
|
|
|
#include <dt-bindings/mux/mux.h>
|
2020-01-13 10:35:13 +00:00
|
|
|
|
2014-02-26 22:59:21 +00:00
|
|
|
/ {
|
|
|
|
model = "sandbox";
|
|
|
|
compatible = "sandbox";
|
|
|
|
#address-cells = <1>;
|
2015-07-06 18:54:36 +00:00
|
|
|
#size-cells = <1>;
|
2014-02-26 22:59:21 +00:00
|
|
|
|
2014-07-23 12:55:03 +00:00
|
|
|
aliases {
|
|
|
|
console = &uart0;
|
2021-02-25 15:51:11 +00:00
|
|
|
ethernet0 = "/eth@10002000";
|
|
|
|
ethernet2 = &swp_0;
|
|
|
|
ethernet3 = ð_3;
|
|
|
|
ethernet4 = &dsa_eth0;
|
|
|
|
ethernet5 = ð_5;
|
sandbox: net: Add aliases for ethernet devices
Commit f3dd213e15 ("net: introduce helpers to get PHY ofnode from MAC")
changed the ethernet sequence assignment from
uclass 36: ethernet
0 * eth@10002000 @ 05813460, seq 0
1 * eth@10003000 @ 05813550, seq 5
2 * sbe5 @ 05813640, seq 3
3 * eth@10004000 @ 05813730, seq 6
4 * dsa-test-eth @ 05813820, seq 4
5 * lan0 @ 05813a30, seq 2
6 * lan1 @ 05813b50, seq 7
to
uclass 36: ethernet
0 * eth@10002000 @ 03813630, seq 0
1 * eth@10003000 @ 03813720, seq 5
2 * sbe5 @ 03813810, seq 3
3 * eth@10004000 @ 03813900, seq 6
4 phy-test-eth @ 038139f0, seq 7
5 * dsa-test-eth @ 03813ae0, seq 4
6 * lan0 @ 03813cf0, seq 2
7 * lan1 @ 03813e10, seq 8
This caused the mac address assignment to switch around. Avoid this in
the future by assigning aliases for all ethernet devices. This reverts
the sequence to what it was before the aformentioned commit (with
phy-test-eth as seq 8). There is no ethernet1 for whatever reason.
Signed-off-by: Sean Anderson <sean.anderson@seco.com>
2022-05-05 17:11:30 +00:00
|
|
|
ethernet6 = "/eth@10004000";
|
|
|
|
ethernet7 = &swp_1;
|
|
|
|
ethernet8 = &phy_eth0;
|
2018-10-01 18:22:40 +00:00
|
|
|
gpio1 = &gpio_a;
|
|
|
|
gpio2 = &gpio_b;
|
2020-01-13 10:35:14 +00:00
|
|
|
gpio3 = &gpio_c;
|
2015-01-25 15:27:05 +00:00
|
|
|
i2c0 = "/i2c@0";
|
2017-04-24 02:02:07 +00:00
|
|
|
mmc0 = "/mmc0";
|
|
|
|
mmc1 = "/mmc1";
|
2022-10-21 00:23:20 +00:00
|
|
|
mmc2 = "/mmc2";
|
|
|
|
mmc3 = "/mmc3";
|
2023-08-24 19:55:41 +00:00
|
|
|
mmc4 = "/mmc4";
|
|
|
|
mmc5 = "/mmc5";
|
2018-08-03 08:14:41 +00:00
|
|
|
pci0 = &pci0;
|
|
|
|
pci1 = &pci1;
|
2018-08-03 08:14:50 +00:00
|
|
|
pci2 = &pci2;
|
2020-06-01 23:47:09 +00:00
|
|
|
remoteproc0 = &rproc_1;
|
|
|
|
remoteproc1 = &rproc_2;
|
2015-05-22 21:42:17 +00:00
|
|
|
rtc0 = &rtc_0;
|
|
|
|
rtc1 = &rtc_1;
|
2015-05-22 21:42:15 +00:00
|
|
|
spi0 = "/spi@0";
|
2015-05-13 11:38:34 +00:00
|
|
|
testfdt6 = "/e-test";
|
2015-01-25 15:27:05 +00:00
|
|
|
testbus3 = "/some-bus";
|
|
|
|
testfdt0 = "/some-bus/c-test@0";
|
2020-12-17 04:20:26 +00:00
|
|
|
testfdt12 = "/some-bus/c-test@1";
|
2015-01-25 15:27:05 +00:00
|
|
|
testfdt3 = "/b-test";
|
|
|
|
testfdt5 = "/some-bus/c-test@5";
|
|
|
|
testfdt8 = "/a-test";
|
2020-12-17 04:20:27 +00:00
|
|
|
testfdtm1 = &testfdtm1;
|
test: dm: Fix wrong aliases property names
After importing v4.17-rc1 Linux commit 9130ba884640 ("scripts/dtc:
Update to upstream version v1.4.6-9-gaadd0b65c987"), sandbox build
reports below warnings:
arch/sandbox/dts/test.dtb: Warning (alias_paths): /aliases: aliases property name must include only lowercase and '-'
arch/sandbox/dts/test.dtb: Warning (alias_paths): /aliases: aliases property name must include only lowercase and '-'
arch/sandbox/dts/test.dtb: Warning (alias_paths): /aliases: aliases property name must include only lowercase and '-'
arch/sandbox/dts/test.dtb: Warning (alias_paths): /aliases: aliases property name must include only lowercase and '-'
Silent them by applying the 's/_/-/' substitution in the names of the
'fdt_dummy0', 'fdt_dummy1', 'fdt_dummy2', 'fdt_dummy3' properties.
Similar DTC warnings have been recently fixed in Linux kernel, e.g. via
v4.17-rc1 commit d366c30d19f4 ("ARM: dts: STi: Fix aliases property name
for STi boards").
If done alone, the DTS update generates a failure of the
`ut dm fdt_translation` unit test in sandbox environment as seen below:
$ ./u-boot -d arch/sandbox/dts/test.dtb
---<-snip->---
=> ut dm fdt_translation
Test: dm_test_fdt_translation: test-fdt.c
test/dm/test-fdt.c:444, dm_test_fdt_translation(): 0 == uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, 1, &dev): Expected 0, got -19
Test: dm_test_fdt_translation: test-fdt.c (flat tree)
test/dm/test-fdt.c:444, dm_test_fdt_translation(): 0 == uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, 1, &dev): Expected 0, got -19
Failures: 2
---<-snip->---
Fix this issue in place, by updating the "name" string in the
UCLASS_DRIVER(fdt_dummy) definition, so that it matches the newly
updated aliases properties. After that, the test passes:
$ ./u-boot -d arch/sandbox/dts/test.dtb
---<-snip->---
=> ut dm fdt_translation
Test: dm_test_fdt_translation: test-fdt.c
Test: dm_test_fdt_translation: test-fdt.c (flat tree)
Failures: 0
---<-snip->---
Fixes: e8d5291824e2 ("core: ofnode: Fix translation for #size-cells == 0")
Reported-by: Petr Vorel <pvorel@suse.cz>
Signed-off-by: Eugeniu Rosca <erosca@de.adit-jv.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
2018-05-19 12:13:55 +00:00
|
|
|
fdt-dummy0 = "/translation-test@8000/dev@0,0";
|
|
|
|
fdt-dummy1 = "/translation-test@8000/dev@1,100";
|
|
|
|
fdt-dummy2 = "/translation-test@8000/dev@2,200";
|
|
|
|
fdt-dummy3 = "/translation-test@8000/noxlatebus@3,300/dev@42";
|
2015-03-25 18:23:05 +00:00
|
|
|
usb0 = &usb_0;
|
|
|
|
usb1 = &usb_1;
|
|
|
|
usb2 = &usb_2;
|
2018-08-09 12:51:19 +00:00
|
|
|
axi0 = &axi;
|
2018-09-27 07:19:31 +00:00
|
|
|
osd0 = "/osd";
|
2014-07-23 12:55:03 +00:00
|
|
|
};
|
|
|
|
|
2022-10-21 00:23:15 +00:00
|
|
|
binman: binman {
|
2022-03-28 20:56:53 +00:00
|
|
|
};
|
|
|
|
|
2021-04-21 09:06:55 +00:00
|
|
|
config {
|
2021-08-07 13:24:01 +00:00
|
|
|
testing-bool;
|
|
|
|
testing-int = <123>;
|
|
|
|
testing-str = "testing";
|
2021-04-21 09:06:55 +00:00
|
|
|
environment {
|
|
|
|
from_fdt = "yes";
|
|
|
|
fdt_env_path = "";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2023-08-31 06:59:05 +00:00
|
|
|
options {
|
|
|
|
u-boot {
|
|
|
|
compatible = "u-boot,config";
|
|
|
|
bootscr-ram-offset = /bits/ 64 <0x12345678>;
|
2023-08-31 07:04:27 +00:00
|
|
|
bootscr-flash-offset = /bits/ 64 <0>;
|
|
|
|
bootscr-flash-size = /bits/ 64 <0x2000>;
|
2023-08-31 06:59:05 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2022-04-25 05:31:24 +00:00
|
|
|
bootstd {
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-verify;
|
2022-04-25 05:31:24 +00:00
|
|
|
compatible = "u-boot,boot-std";
|
|
|
|
|
|
|
|
filename-prefixes = "/", "/boot/";
|
|
|
|
bootdev-order = "mmc2", "mmc1";
|
|
|
|
|
2023-05-10 22:34:46 +00:00
|
|
|
extlinux {
|
|
|
|
compatible = "u-boot,extlinux";
|
2022-04-25 05:31:24 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
efi {
|
|
|
|
compatible = "u-boot,distro-efi";
|
|
|
|
};
|
2022-10-21 00:23:14 +00:00
|
|
|
|
2023-01-06 14:52:41 +00:00
|
|
|
theme {
|
|
|
|
font-size = <30>;
|
2023-06-01 16:23:00 +00:00
|
|
|
menu-inset = <3>;
|
|
|
|
menuitem-gap-y = <1>;
|
2023-01-06 14:52:41 +00:00
|
|
|
};
|
|
|
|
|
2023-08-14 22:40:30 +00:00
|
|
|
cedit-theme {
|
|
|
|
font-size = <30>;
|
|
|
|
menu-inset = <3>;
|
|
|
|
menuitem-gap-y = <1>;
|
|
|
|
};
|
|
|
|
|
2022-10-21 00:23:20 +00:00
|
|
|
/*
|
|
|
|
* This is used for the VBE OS-request tests. A FAT filesystem
|
|
|
|
* created in a partition with the VBE information appearing
|
2023-09-07 12:55:48 +00:00
|
|
|
* before the partition starts
|
2022-10-21 00:23:20 +00:00
|
|
|
*/
|
2022-10-21 00:23:14 +00:00
|
|
|
firmware0 {
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-verify;
|
2022-10-21 00:23:14 +00:00
|
|
|
compatible = "fwupd,vbe-simple";
|
|
|
|
storage = "mmc1";
|
|
|
|
skip-offset = <0x200>;
|
|
|
|
area-start = <0x400>;
|
|
|
|
area-size = <0x1000>;
|
|
|
|
state-offset = <0x400>;
|
|
|
|
state-size = <0x40>;
|
|
|
|
version-offset = <0x800>;
|
|
|
|
version-size = <0x100>;
|
|
|
|
};
|
2022-10-21 00:23:20 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* This is used for the VBE VPL tests. The MMC device holds the
|
|
|
|
* binman image.bin file. The test progresses through each phase
|
|
|
|
* of U-Boot, loading each in turn from MMC.
|
|
|
|
*
|
|
|
|
* Note that the test enables this node (and mmc3) before
|
|
|
|
* running U-Boot
|
|
|
|
*/
|
|
|
|
firmware1 {
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-verify;
|
2022-10-21 00:23:20 +00:00
|
|
|
status = "disabled";
|
|
|
|
compatible = "fwupd,vbe-simple";
|
|
|
|
storage = "mmc3";
|
2023-04-02 02:01:24 +00:00
|
|
|
skip-offset = <0x800000>;
|
2022-10-21 00:23:20 +00:00
|
|
|
area-start = <0>;
|
|
|
|
area-size = <0xe00000>;
|
|
|
|
state-offset = <0xdffc00>;
|
|
|
|
state-size = <0x40>;
|
|
|
|
version-offset = <0xdffe00>;
|
|
|
|
version-size = <0x100>;
|
|
|
|
};
|
2022-04-25 05:31:24 +00:00
|
|
|
};
|
|
|
|
|
2023-06-01 16:23:01 +00:00
|
|
|
cedit: cedit {
|
|
|
|
};
|
|
|
|
|
2022-05-30 10:00:12 +00:00
|
|
|
fuzzing-engine {
|
|
|
|
compatible = "sandbox,fuzzing-engine";
|
|
|
|
};
|
|
|
|
|
2021-06-10 13:56:44 +00:00
|
|
|
reboot-mode0 {
|
|
|
|
compatible = "reboot-mode-gpio";
|
|
|
|
gpios = <&gpio_c 0 GPIO_ACTIVE_HIGH>, <&gpio_c 1 GPIO_ACTIVE_HIGH>;
|
|
|
|
u-boot,env-variable = "bootstatus";
|
|
|
|
mode-test = <0x01>;
|
|
|
|
mode-download = <0x03>;
|
|
|
|
};
|
|
|
|
|
2021-06-10 13:56:45 +00:00
|
|
|
reboot_mode1: reboot-mode@14 {
|
|
|
|
compatible = "reboot-mode-rtc";
|
|
|
|
rtc = <&rtc_0>;
|
|
|
|
reg = <0x30 4>;
|
|
|
|
u-boot,env-variable = "bootstatus";
|
|
|
|
big-endian;
|
|
|
|
mode-test = <0x21969147>;
|
|
|
|
mode-download = <0x51939147>;
|
|
|
|
};
|
|
|
|
|
2018-12-10 17:37:33 +00:00
|
|
|
audio: audio-codec {
|
|
|
|
compatible = "sandbox,audio-codec";
|
|
|
|
#sound-dai-cells = <1>;
|
|
|
|
};
|
|
|
|
|
2020-07-24 16:19:51 +00:00
|
|
|
buttons {
|
|
|
|
compatible = "gpio-keys";
|
|
|
|
|
2020-09-14 10:50:54 +00:00
|
|
|
btn1 {
|
2020-07-24 16:19:51 +00:00
|
|
|
gpios = <&gpio_a 3 0>;
|
2020-09-14 10:50:54 +00:00
|
|
|
label = "button1";
|
2023-01-22 15:21:24 +00:00
|
|
|
linux,code = <BTN_1>;
|
2020-07-24 16:19:51 +00:00
|
|
|
};
|
|
|
|
|
2020-09-14 10:50:54 +00:00
|
|
|
btn2 {
|
2020-07-24 16:19:51 +00:00
|
|
|
gpios = <&gpio_a 4 0>;
|
2020-09-14 10:50:54 +00:00
|
|
|
label = "button2";
|
2023-01-22 15:21:24 +00:00
|
|
|
linux,code = <BTN_2>;
|
2020-07-24 16:19:51 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2021-02-18 10:33:18 +00:00
|
|
|
buttons2 {
|
|
|
|
compatible = "adc-keys";
|
|
|
|
io-channels = <&adc 3>;
|
|
|
|
keyup-threshold-microvolt = <3000000>;
|
|
|
|
|
|
|
|
button-up {
|
|
|
|
label = "button3";
|
|
|
|
linux,code = <KEY_F3>;
|
|
|
|
press-threshold-microvolt = <1500000>;
|
|
|
|
};
|
|
|
|
|
|
|
|
button-down {
|
|
|
|
label = "button4";
|
|
|
|
linux,code = <KEY_F4>;
|
|
|
|
press-threshold-microvolt = <1000000>;
|
|
|
|
};
|
|
|
|
|
|
|
|
button-enter {
|
|
|
|
label = "button5";
|
|
|
|
linux,code = <KEY_F5>;
|
|
|
|
press-threshold-microvolt = <500000>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-12-10 17:37:34 +00:00
|
|
|
cros_ec: cros-ec {
|
2018-10-01 18:22:08 +00:00
|
|
|
reg = <0 0>;
|
|
|
|
compatible = "google,cros-ec-sandbox";
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This describes the flash memory within the EC. Note
|
|
|
|
* that the STM32L flash erases to 0, not 0xff.
|
|
|
|
*/
|
|
|
|
flash {
|
|
|
|
image-pos = <0x08000000>;
|
|
|
|
size = <0x20000>;
|
|
|
|
erase-value = <0>;
|
|
|
|
|
|
|
|
/* Information for sandbox */
|
|
|
|
ro {
|
|
|
|
image-pos = <0>;
|
|
|
|
size = <0xf000>;
|
|
|
|
};
|
|
|
|
wp-ro {
|
|
|
|
image-pos = <0xf000>;
|
|
|
|
size = <0x1000>;
|
2021-01-21 20:57:14 +00:00
|
|
|
used = <0x884>;
|
|
|
|
compress = "lz4";
|
|
|
|
uncomp-size = <0xcf8>;
|
|
|
|
hash {
|
|
|
|
algo = "sha256";
|
|
|
|
value = [00 01 02 03 04 05 06 07
|
|
|
|
08 09 0a 0b 0c 0d 0e 0f
|
|
|
|
10 11 12 13 14 15 16 17
|
|
|
|
18 19 1a 1b 1c 1d 1e 1f];
|
|
|
|
};
|
2018-10-01 18:22:08 +00:00
|
|
|
};
|
|
|
|
rw {
|
|
|
|
image-pos = <0x10000>;
|
|
|
|
size = <0x10000>;
|
|
|
|
};
|
|
|
|
};
|
2021-05-19 16:33:31 +00:00
|
|
|
|
|
|
|
cros_ec_pwm: cros-ec-pwm {
|
|
|
|
compatible = "google,cros-ec-pwm";
|
|
|
|
#pwm-cells = <1>;
|
|
|
|
};
|
|
|
|
|
2018-10-01 18:22:08 +00:00
|
|
|
};
|
|
|
|
|
2019-10-07 13:29:05 +00:00
|
|
|
dsi_host: dsi_host {
|
|
|
|
compatible = "sandbox,dsi-host";
|
|
|
|
};
|
|
|
|
|
2014-02-26 22:59:21 +00:00
|
|
|
a-test {
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <0 1>;
|
2014-02-26 22:59:21 +00:00
|
|
|
compatible = "denx,u-boot-fdt-test";
|
2014-07-23 12:54:57 +00:00
|
|
|
ping-expect = <0>;
|
2014-02-26 22:59:21 +00:00
|
|
|
ping-add = <0>;
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-all;
|
2020-01-13 10:35:13 +00:00
|
|
|
test-gpios = <&gpio_a 1>, <&gpio_a 4>,
|
|
|
|
<&gpio_b 5 GPIO_ACTIVE_HIGH 3 2 1>,
|
dm: gpio: Add better functions to request GPIOs
At present U-Boot sort-of supports the standard way of reading GPIOs from
device tree nodes, but the support is incomplete, a bit clunky and only
works for GPIO bindings where #gpio-cells is 2.
Add new functions to request GPIOs, taking full account of the device
tree binding. These permit requesting a GPIO with a simple call like:
gpio_request_by_name(dev, "cd-gpios", 0, &desc, GPIOD_IS_IN);
This will request the GPIO, looking at the device's node which might be
this, for example:
cd-gpios = <&gpio TEGRA_GPIO(B, 3) GPIO_ACTIVE_LOW>;
The GPIO will be set to input mode in this case and polarity will be
honoured by the GPIO calls.
It is also possible to request and free a list of GPIOs.
Signed-off-by: Simon Glass <sjg@chromium.org>
2015-01-06 03:05:29 +00:00
|
|
|
<0>, <&gpio_a 12>;
|
2020-01-13 10:35:13 +00:00
|
|
|
test2-gpios = <&gpio_a 1>, <&gpio_a 4>,
|
|
|
|
<&gpio_b 6 GPIO_ACTIVE_LOW 3 2 1>,
|
|
|
|
<&gpio_b 7 GPIO_IN 3 2 1>,
|
|
|
|
<&gpio_b 8 GPIO_OUT 3 2 1>,
|
|
|
|
<&gpio_b 9 (GPIO_OUT|GPIO_OUT_ACTIVE) 3 2 1>;
|
2020-01-13 10:35:14 +00:00
|
|
|
test3-gpios =
|
|
|
|
<&gpio_c 0 (GPIO_OUT|GPIO_OPEN_DRAIN)>,
|
|
|
|
<&gpio_c 1 (GPIO_OUT|GPIO_OPEN_SOURCE)>,
|
|
|
|
<&gpio_c 2 GPIO_OUT>,
|
|
|
|
<&gpio_c 3 (GPIO_IN|GPIO_PULL_UP)>,
|
|
|
|
<&gpio_c 4 (GPIO_IN|GPIO_PULL_DOWN)>,
|
2020-05-05 08:43:18 +00:00
|
|
|
<&gpio_c 5 GPIO_IN>,
|
|
|
|
<&gpio_c 6 (GPIO_ACTIVE_LOW|GPIO_OUT|GPIO_OPEN_DRAIN)>,
|
|
|
|
<&gpio_c 7 (GPIO_ACTIVE_LOW|GPIO_OUT|GPIO_OPEN_SOURCE)>;
|
2020-09-11 08:13:35 +00:00
|
|
|
test4-gpios = <&gpio_a 14>, <&gpio_b 4 1 3 2 1>;
|
|
|
|
test5-gpios = <&gpio_a 19>;
|
|
|
|
|
2021-10-23 23:26:04 +00:00
|
|
|
bool-value;
|
2022-06-14 13:21:30 +00:00
|
|
|
int8-value = /bits/ 8 <0x12>;
|
|
|
|
int16-value = /bits/ 16 <0x1234>;
|
2018-12-10 17:37:37 +00:00
|
|
|
int-value = <1234>;
|
|
|
|
uint-value = <(-1234)>;
|
2020-03-29 16:04:40 +00:00
|
|
|
int64-value = /bits/ 64 <0x1111222233334444>;
|
2020-03-29 16:04:41 +00:00
|
|
|
int-array = <5678 9123 4567>;
|
2023-08-25 09:37:46 +00:00
|
|
|
int64-array = /bits/ 64 <0x1111222233334444 0x4444333322221111>;
|
2020-07-07 19:11:58 +00:00
|
|
|
str-value = "test string";
|
2020-02-06 16:55:00 +00:00
|
|
|
interrupts-extended = <&irq 3 0>;
|
2020-07-07 19:12:11 +00:00
|
|
|
acpi,name = "GHIJ";
|
2020-09-25 07:41:16 +00:00
|
|
|
phandle-value = <&gpio_c 10>, <0xFFFFFFFF 20>, <&gpio_a 30>;
|
2020-10-16 10:46:34 +00:00
|
|
|
|
|
|
|
mux-controls = <&muxcontroller0 0>, <&muxcontroller0 1>,
|
|
|
|
<&muxcontroller0 2>, <&muxcontroller0 3>,
|
|
|
|
<&muxcontroller1>;
|
|
|
|
mux-control-names = "mux0", "mux1", "mux2", "mux3", "mux4";
|
|
|
|
mux-syscon = <&syscon3>;
|
2020-12-29 23:16:26 +00:00
|
|
|
display-timings {
|
|
|
|
timing0: 240x320 {
|
|
|
|
clock-frequency = <6500000>;
|
|
|
|
hactive = <240>;
|
|
|
|
vactive = <320>;
|
|
|
|
hfront-porch = <6>;
|
|
|
|
hback-porch = <7>;
|
|
|
|
hsync-len = <1>;
|
|
|
|
vback-porch = <5>;
|
|
|
|
vfront-porch = <8>;
|
|
|
|
vsync-len = <2>;
|
|
|
|
hsync-active = <1>;
|
|
|
|
vsync-active = <0>;
|
|
|
|
de-active = <1>;
|
|
|
|
pixelclk-active = <1>;
|
|
|
|
interlaced;
|
|
|
|
doublescan;
|
|
|
|
doubleclk;
|
|
|
|
};
|
|
|
|
timing1: 480x800 {
|
|
|
|
clock-frequency = <9000000>;
|
|
|
|
hactive = <480>;
|
|
|
|
vactive = <800>;
|
|
|
|
hfront-porch = <10>;
|
|
|
|
hback-porch = <59>;
|
|
|
|
hsync-len = <12>;
|
|
|
|
vback-porch = <15>;
|
|
|
|
vfront-porch = <17>;
|
|
|
|
vsync-len = <16>;
|
|
|
|
hsync-active = <0>;
|
|
|
|
vsync-active = <1>;
|
|
|
|
de-active = <0>;
|
|
|
|
pixelclk-active = <0>;
|
|
|
|
};
|
|
|
|
timing2: 800x480 {
|
|
|
|
clock-frequency = <33500000>;
|
|
|
|
hactive = <800>;
|
|
|
|
vactive = <480>;
|
|
|
|
hback-porch = <89>;
|
|
|
|
hfront-porch = <164>;
|
|
|
|
vback-porch = <23>;
|
|
|
|
vfront-porch = <10>;
|
|
|
|
hsync-len = <11>;
|
|
|
|
vsync-len = <13>;
|
|
|
|
};
|
|
|
|
};
|
2023-05-11 14:36:52 +00:00
|
|
|
panel-timing {
|
2023-01-31 10:05:15 +00:00
|
|
|
clock-frequency = <6500000>;
|
|
|
|
hactive = <240>;
|
|
|
|
vactive = <320>;
|
|
|
|
hfront-porch = <6>;
|
|
|
|
hback-porch = <7>;
|
|
|
|
hsync-len = <1>;
|
|
|
|
vback-porch = <5>;
|
|
|
|
vfront-porch = <8>;
|
|
|
|
vsync-len = <2>;
|
|
|
|
hsync-active = <1>;
|
|
|
|
vsync-active = <0>;
|
|
|
|
de-active = <1>;
|
|
|
|
pixelclk-active = <1>;
|
|
|
|
interlaced;
|
|
|
|
doublescan;
|
|
|
|
doubleclk;
|
|
|
|
};
|
2014-02-26 22:59:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
junk {
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <1 1>;
|
2014-02-26 22:59:21 +00:00
|
|
|
compatible = "not,compatible";
|
|
|
|
};
|
|
|
|
|
|
|
|
no-compatible {
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <2 1>;
|
2014-02-26 22:59:21 +00:00
|
|
|
};
|
|
|
|
|
2018-10-01 18:22:40 +00:00
|
|
|
backlight: backlight {
|
|
|
|
compatible = "pwm-backlight";
|
|
|
|
enable-gpios = <&gpio_a 1>;
|
|
|
|
power-supply = <&ldo_1>;
|
|
|
|
pwms = <&pwm 0 1000>;
|
|
|
|
default-brightness-level = <5>;
|
|
|
|
brightness-levels = <0 16 32 64 128 170 202 234 255>;
|
|
|
|
};
|
|
|
|
|
2018-08-09 14:17:46 +00:00
|
|
|
bind-test {
|
2020-07-28 07:13:33 +00:00
|
|
|
compatible = "simple-bus";
|
2018-08-09 14:17:46 +00:00
|
|
|
bind-test-child1 {
|
|
|
|
compatible = "sandbox,phy";
|
|
|
|
#phy-cells = <1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
bind-test-child2 {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-02-26 22:59:21 +00:00
|
|
|
b-test {
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <3 1>;
|
2014-02-26 22:59:21 +00:00
|
|
|
compatible = "denx,u-boot-fdt-test";
|
2014-07-23 12:54:57 +00:00
|
|
|
ping-expect = <3>;
|
2014-02-26 22:59:21 +00:00
|
|
|
ping-add = <3>;
|
2020-10-16 10:46:34 +00:00
|
|
|
|
|
|
|
mux-controls = <&muxcontroller0 0>;
|
|
|
|
mux-control-names = "mux0";
|
2014-02-26 22:59:21 +00:00
|
|
|
};
|
|
|
|
|
2017-04-24 09:51:28 +00:00
|
|
|
phy_provider0: gen_phy@0 {
|
|
|
|
compatible = "sandbox,phy";
|
|
|
|
#phy-cells = <1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
phy_provider1: gen_phy@1 {
|
|
|
|
compatible = "sandbox,phy";
|
|
|
|
#phy-cells = <0>;
|
|
|
|
broken;
|
|
|
|
};
|
|
|
|
|
2020-05-02 09:35:12 +00:00
|
|
|
phy_provider2: gen_phy@2 {
|
|
|
|
compatible = "sandbox,phy";
|
|
|
|
#phy-cells = <0>;
|
|
|
|
};
|
|
|
|
|
2023-08-31 22:16:35 +00:00
|
|
|
phy_provider3: gen_phy@3 {
|
|
|
|
compatible = "sandbox,phy";
|
|
|
|
#phy-cells = <2>;
|
|
|
|
};
|
|
|
|
|
2017-04-24 09:51:28 +00:00
|
|
|
gen_phy_user: gen_phy_user {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
phys = <&phy_provider0 0>, <&phy_provider0 1>, <&phy_provider1>;
|
|
|
|
phy-names = "phy1", "phy2", "phy3";
|
|
|
|
};
|
|
|
|
|
2020-05-02 09:35:12 +00:00
|
|
|
gen_phy_user1: gen_phy_user1 {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
phys = <&phy_provider0 0>, <&phy_provider2>;
|
|
|
|
phy-names = "phy1", "phy2";
|
|
|
|
};
|
|
|
|
|
2023-08-31 22:16:35 +00:00
|
|
|
gen_phy_user2: gen_phy_user2 {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
phys = <&phy_provider3 0 0>;
|
|
|
|
phy-names = "phy1";
|
|
|
|
};
|
|
|
|
|
2014-02-26 22:59:21 +00:00
|
|
|
some-bus {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2014-07-23 12:55:18 +00:00
|
|
|
compatible = "denx,u-boot-test-bus";
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <3 1>;
|
2014-07-23 12:54:57 +00:00
|
|
|
ping-expect = <4>;
|
2014-02-26 22:59:21 +00:00
|
|
|
ping-add = <4>;
|
2014-07-23 12:55:18 +00:00
|
|
|
c-test@5 {
|
2014-02-26 22:59:21 +00:00
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
reg = <5>;
|
2014-07-23 12:55:18 +00:00
|
|
|
ping-expect = <5>;
|
2014-02-26 22:59:21 +00:00
|
|
|
ping-add = <5>;
|
|
|
|
};
|
2014-07-23 12:55:18 +00:00
|
|
|
c-test@0 {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
reg = <0>;
|
|
|
|
ping-expect = <6>;
|
|
|
|
ping-add = <6>;
|
|
|
|
};
|
|
|
|
c-test@1 {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
reg = <1>;
|
|
|
|
ping-expect = <7>;
|
|
|
|
ping-add = <7>;
|
|
|
|
};
|
2014-02-26 22:59:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
d-test {
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <3 1>;
|
2014-07-23 12:55:12 +00:00
|
|
|
ping-expect = <6>;
|
|
|
|
ping-add = <6>;
|
|
|
|
compatible = "google,another-fdt-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
e-test {
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <3 1>;
|
2014-07-23 12:54:57 +00:00
|
|
|
ping-expect = <6>;
|
2014-02-26 22:59:21 +00:00
|
|
|
ping-add = <6>;
|
|
|
|
compatible = "google,another-fdt-test";
|
|
|
|
};
|
|
|
|
|
2015-01-25 15:27:05 +00:00
|
|
|
f-test {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
g-test {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
};
|
|
|
|
|
2018-10-11 05:07:01 +00:00
|
|
|
h-test {
|
|
|
|
compatible = "denx,u-boot-fdt-test1";
|
|
|
|
};
|
|
|
|
|
2020-05-02 09:35:10 +00:00
|
|
|
i-test {
|
|
|
|
compatible = "mediatek,u-boot-fdt-test";
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
|
|
|
|
|
|
|
subnode@0 {
|
|
|
|
reg = <0>;
|
|
|
|
};
|
|
|
|
|
|
|
|
subnode@1 {
|
|
|
|
reg = <1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
subnode@2 {
|
|
|
|
reg = <2>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2019-12-30 04:19:25 +00:00
|
|
|
devres-test {
|
|
|
|
compatible = "denx,u-boot-devres-test";
|
|
|
|
};
|
|
|
|
|
2020-09-11 08:13:35 +00:00
|
|
|
another-test {
|
|
|
|
reg = <0 2>;
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
test4-gpios = <&gpio_a 14>, <&gpio_b 4 1 3 2 1>;
|
|
|
|
test5-gpios = <&gpio_a 19>;
|
|
|
|
};
|
|
|
|
|
2021-01-12 12:55:23 +00:00
|
|
|
mmio-bus@0 {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
|
|
|
compatible = "denx,u-boot-test-bus";
|
|
|
|
dma-ranges = <0x10000000 0x00000000 0x00040000>;
|
|
|
|
|
|
|
|
subnode@0 {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
mmio-bus@1 {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
|
|
|
compatible = "denx,u-boot-test-bus";
|
2021-01-12 12:55:25 +00:00
|
|
|
|
|
|
|
subnode@0 {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
};
|
2021-01-12 12:55:23 +00:00
|
|
|
};
|
|
|
|
|
2020-07-07 19:12:06 +00:00
|
|
|
acpi_test1: acpi-test {
|
2020-04-08 22:57:34 +00:00
|
|
|
compatible = "denx,u-boot-acpi-test";
|
2020-07-07 19:12:03 +00:00
|
|
|
acpi-ssdt-test-data = "ab";
|
2020-07-07 19:12:08 +00:00
|
|
|
acpi-dsdt-test-data = "hi";
|
2020-07-07 19:11:39 +00:00
|
|
|
child {
|
|
|
|
compatible = "denx,u-boot-acpi-test";
|
|
|
|
};
|
2020-04-08 22:57:34 +00:00
|
|
|
};
|
|
|
|
|
2020-07-07 19:12:06 +00:00
|
|
|
acpi_test2: acpi-test2 {
|
2020-04-26 15:19:46 +00:00
|
|
|
compatible = "denx,u-boot-acpi-test";
|
2020-07-07 19:12:03 +00:00
|
|
|
acpi-ssdt-test-data = "cd";
|
2020-07-07 19:12:08 +00:00
|
|
|
acpi-dsdt-test-data = "jk";
|
2020-04-26 15:19:46 +00:00
|
|
|
};
|
|
|
|
|
2017-09-04 12:55:57 +00:00
|
|
|
clocks {
|
|
|
|
clk_fixed: clk-fixed {
|
|
|
|
compatible = "fixed-clock";
|
|
|
|
#clock-cells = <0>;
|
|
|
|
clock-frequency = <1234>;
|
|
|
|
};
|
2019-02-25 08:14:55 +00:00
|
|
|
|
|
|
|
clk_fixed_factor: clk-fixed-factor {
|
|
|
|
compatible = "fixed-factor-clock";
|
|
|
|
#clock-cells = <0>;
|
|
|
|
clock-div = <3>;
|
|
|
|
clock-mult = <2>;
|
|
|
|
clocks = <&clk_fixed>;
|
|
|
|
};
|
2019-06-24 13:50:47 +00:00
|
|
|
|
|
|
|
osc {
|
|
|
|
compatible = "fixed-clock";
|
|
|
|
#clock-cells = <0>;
|
|
|
|
clock-frequency = <20000000>;
|
|
|
|
};
|
2016-06-17 15:44:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
clk_sandbox: clk-sbox {
|
2015-07-06 18:54:24 +00:00
|
|
|
compatible = "sandbox,clk";
|
2016-06-17 15:44:00 +00:00
|
|
|
#clock-cells = <1>;
|
2019-10-22 12:00:07 +00:00
|
|
|
assigned-clocks = <&clk_sandbox 3>;
|
|
|
|
assigned-clock-rates = <321>;
|
2016-06-17 15:44:00 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
clk-test {
|
|
|
|
compatible = "sandbox,clk-test";
|
|
|
|
clocks = <&clk_fixed>,
|
|
|
|
<&clk_sandbox 1>,
|
2019-10-22 12:00:05 +00:00
|
|
|
<&clk_sandbox 0>,
|
|
|
|
<&clk_sandbox 3>,
|
|
|
|
<&clk_sandbox 2>;
|
|
|
|
clock-names = "fixed", "i2c", "spi", "uart2", "uart1";
|
2015-07-06 18:54:24 +00:00
|
|
|
};
|
|
|
|
|
2023-08-30 08:31:42 +00:00
|
|
|
clk-test2 {
|
|
|
|
compatible = "sandbox,clk-test";
|
|
|
|
assigned-clock-rates = <321>;
|
|
|
|
};
|
|
|
|
|
|
|
|
clk-test3 {
|
|
|
|
compatible = "sandbox,clk-test";
|
|
|
|
assigned-clocks = <&clk_sandbox 1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
clk-test4 {
|
|
|
|
compatible = "sandbox,clk-test";
|
|
|
|
assigned-clock-rates = <654>, <321>;
|
|
|
|
assigned-clocks = <&clk_sandbox 1>;
|
|
|
|
};
|
|
|
|
|
2019-06-24 13:50:50 +00:00
|
|
|
ccf: clk-ccf {
|
|
|
|
compatible = "sandbox,clk-ccf";
|
|
|
|
};
|
|
|
|
|
2021-12-04 15:56:31 +00:00
|
|
|
efi-media {
|
|
|
|
compatible = "sandbox,efi-media";
|
|
|
|
};
|
|
|
|
|
2015-05-22 21:42:15 +00:00
|
|
|
eth@10002000 {
|
|
|
|
compatible = "sandbox,eth";
|
|
|
|
reg = <0x10002000 0x1000>;
|
|
|
|
};
|
|
|
|
|
|
|
|
eth_5: eth@10003000 {
|
|
|
|
compatible = "sandbox,eth";
|
|
|
|
reg = <0x10003000 0x1000>;
|
2022-05-05 17:11:44 +00:00
|
|
|
nvmem-cells = <ð5_addr>;
|
|
|
|
nvmem-cell-names = "mac-address";
|
2015-05-22 21:42:15 +00:00
|
|
|
};
|
|
|
|
|
2015-08-28 05:25:53 +00:00
|
|
|
eth_3: sbe5 {
|
|
|
|
compatible = "sandbox,eth";
|
|
|
|
reg = <0x10005000 0x1000>;
|
2022-05-05 17:11:42 +00:00
|
|
|
nvmem-cells = <ð3_addr>;
|
|
|
|
nvmem-cell-names = "mac-address";
|
2015-08-28 05:25:53 +00:00
|
|
|
};
|
|
|
|
|
2015-05-22 21:42:15 +00:00
|
|
|
eth@10004000 {
|
|
|
|
compatible = "sandbox,eth";
|
|
|
|
reg = <0x10004000 0x1000>;
|
|
|
|
};
|
|
|
|
|
2022-04-06 22:32:57 +00:00
|
|
|
phy_eth0: phy-test-eth {
|
|
|
|
compatible = "sandbox,eth";
|
|
|
|
reg = <0x10007000 0x1000>;
|
2022-05-05 17:11:35 +00:00
|
|
|
mac-address = [ 02 00 11 22 33 49 ];
|
2022-04-06 22:32:57 +00:00
|
|
|
phy-handle = <ðphy1>;
|
2022-04-06 22:33:01 +00:00
|
|
|
phy-mode = "2500base-x";
|
2022-04-06 22:32:57 +00:00
|
|
|
};
|
|
|
|
|
sandbox: Add a DSA sandbox driver and unit test
The DSA sandbox driver is used for unit testing the DSA class code.
It implements a simple 2 port switch plus 1 CPU port, and uses a
very simple tag to identify the ports.
The DSA sandbox device is connected via CPU port to a regular Ethernet
sandbox device, called 'dsa-test-eth, managed by the existing eth
sandbox driver. The 'dsa-test-eth' is not intended for testing the
eth class code however, but it is used to emulate traffic through the
'lan0' and 'lan1' front pannel switch ports. To achieve this the dsa
sandbox driver registers a tx handler for the 'dsa-test-eth' device.
The switch ports, labeled as 'lan0' and 'lan1', are also registered
as eth devices by the dsa class code this time. So pinging through
these switch ports is as easy as:
=> setenv ethact lan0
=> ping 1.2.3.5
Unit tests for the dsa class code were also added. The 'dsa_probe'
test exercises most API functions from dsa.h. The 'dsa' unit test
simply exercises ARP/ICMP traffic through the two switch ports,
including tag injection and extraction, with the help of the dsa
sandbox driver.
I took care to minimize the impact on the existing eth unit tests,
though some adjustments needed to be made with the addition of
extra eth interfaces used by the dsa unit tests. The additional eth
interfaces also require MAC addresses, these have been added to the
sandbox default environment.
Signed-off-by: Alex Marginean <alexandru.marginean@nxp.com>
Signed-off-by: Claudiu Manoil <claudiu.manoil@nxp.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Message-Id: <20210216224804.3355044-5-olteanv@gmail.com>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
Reviewed-by: Priyanka Jain <priyanka.jain@nxp.com>
2021-03-14 12:14:57 +00:00
|
|
|
dsa_eth0: dsa-test-eth {
|
|
|
|
compatible = "sandbox,eth";
|
|
|
|
reg = <0x10006000 0x1000>;
|
2022-05-05 17:11:43 +00:00
|
|
|
nvmem-cells = <ð4_addr>;
|
|
|
|
nvmem-cell-names = "mac-address";
|
sandbox: Add a DSA sandbox driver and unit test
The DSA sandbox driver is used for unit testing the DSA class code.
It implements a simple 2 port switch plus 1 CPU port, and uses a
very simple tag to identify the ports.
The DSA sandbox device is connected via CPU port to a regular Ethernet
sandbox device, called 'dsa-test-eth, managed by the existing eth
sandbox driver. The 'dsa-test-eth' is not intended for testing the
eth class code however, but it is used to emulate traffic through the
'lan0' and 'lan1' front pannel switch ports. To achieve this the dsa
sandbox driver registers a tx handler for the 'dsa-test-eth' device.
The switch ports, labeled as 'lan0' and 'lan1', are also registered
as eth devices by the dsa class code this time. So pinging through
these switch ports is as easy as:
=> setenv ethact lan0
=> ping 1.2.3.5
Unit tests for the dsa class code were also added. The 'dsa_probe'
test exercises most API functions from dsa.h. The 'dsa' unit test
simply exercises ARP/ICMP traffic through the two switch ports,
including tag injection and extraction, with the help of the dsa
sandbox driver.
I took care to minimize the impact on the existing eth unit tests,
though some adjustments needed to be made with the addition of
extra eth interfaces used by the dsa unit tests. The additional eth
interfaces also require MAC addresses, these have been added to the
sandbox default environment.
Signed-off-by: Alex Marginean <alexandru.marginean@nxp.com>
Signed-off-by: Claudiu Manoil <claudiu.manoil@nxp.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Message-Id: <20210216224804.3355044-5-olteanv@gmail.com>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
Reviewed-by: Priyanka Jain <priyanka.jain@nxp.com>
2021-03-14 12:14:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
dsa-test {
|
|
|
|
compatible = "sandbox,dsa";
|
|
|
|
|
|
|
|
ports {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
|
|
|
swp_0: port@0 {
|
|
|
|
reg = <0>;
|
|
|
|
label = "lan0";
|
|
|
|
phy-mode = "rgmii-rxid";
|
|
|
|
|
|
|
|
fixed-link {
|
|
|
|
speed = <100>;
|
|
|
|
full-duplex;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
swp_1: port@1 {
|
|
|
|
reg = <1>;
|
|
|
|
label = "lan1";
|
|
|
|
phy-mode = "rgmii-txid";
|
2021-03-14 12:14:58 +00:00
|
|
|
fixed-link = <0 1 100 0 0>;
|
sandbox: Add a DSA sandbox driver and unit test
The DSA sandbox driver is used for unit testing the DSA class code.
It implements a simple 2 port switch plus 1 CPU port, and uses a
very simple tag to identify the ports.
The DSA sandbox device is connected via CPU port to a regular Ethernet
sandbox device, called 'dsa-test-eth, managed by the existing eth
sandbox driver. The 'dsa-test-eth' is not intended for testing the
eth class code however, but it is used to emulate traffic through the
'lan0' and 'lan1' front pannel switch ports. To achieve this the dsa
sandbox driver registers a tx handler for the 'dsa-test-eth' device.
The switch ports, labeled as 'lan0' and 'lan1', are also registered
as eth devices by the dsa class code this time. So pinging through
these switch ports is as easy as:
=> setenv ethact lan0
=> ping 1.2.3.5
Unit tests for the dsa class code were also added. The 'dsa_probe'
test exercises most API functions from dsa.h. The 'dsa' unit test
simply exercises ARP/ICMP traffic through the two switch ports,
including tag injection and extraction, with the help of the dsa
sandbox driver.
I took care to minimize the impact on the existing eth unit tests,
though some adjustments needed to be made with the addition of
extra eth interfaces used by the dsa unit tests. The additional eth
interfaces also require MAC addresses, these have been added to the
sandbox default environment.
Signed-off-by: Alex Marginean <alexandru.marginean@nxp.com>
Signed-off-by: Claudiu Manoil <claudiu.manoil@nxp.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com>
Message-Id: <20210216224804.3355044-5-olteanv@gmail.com>
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
Reviewed-by: Priyanka Jain <priyanka.jain@nxp.com>
2021-03-14 12:14:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
port@2 {
|
|
|
|
reg = <2>;
|
|
|
|
ethernet = <&dsa_eth0>;
|
|
|
|
|
|
|
|
fixed-link {
|
|
|
|
speed = <1000>;
|
|
|
|
full-duplex;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-09-19 10:43:46 +00:00
|
|
|
firmware {
|
|
|
|
sandbox_firmware: sandbox-firmware {
|
|
|
|
compatible = "sandbox,firmware";
|
|
|
|
};
|
2020-09-09 16:44:00 +00:00
|
|
|
|
2022-02-21 08:22:39 +00:00
|
|
|
scmi {
|
2020-09-09 16:44:00 +00:00
|
|
|
compatible = "sandbox,scmi-agent";
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2020-09-09 16:44:05 +00:00
|
|
|
|
2022-02-21 08:22:39 +00:00
|
|
|
clk_scmi: protocol@14 {
|
2020-09-09 16:44:05 +00:00
|
|
|
reg = <0x14>;
|
|
|
|
#clock-cells = <1>;
|
2023-10-11 10:06:59 +00:00
|
|
|
linaro,sandbox-channel-id = <0x14>;
|
2020-09-09 16:44:05 +00:00
|
|
|
};
|
2020-09-09 16:44:07 +00:00
|
|
|
|
2022-02-21 08:22:39 +00:00
|
|
|
reset_scmi: protocol@16 {
|
2020-09-09 16:44:07 +00:00
|
|
|
reg = <0x16>;
|
|
|
|
#reset-cells = <1>;
|
|
|
|
};
|
2021-03-08 21:38:07 +00:00
|
|
|
|
|
|
|
protocol@17 {
|
|
|
|
reg = <0x17>;
|
|
|
|
|
|
|
|
regulators {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
|
|
|
|
2022-02-21 08:22:39 +00:00
|
|
|
regul0_scmi: reg@0 {
|
2021-03-08 21:38:07 +00:00
|
|
|
reg = <0>;
|
|
|
|
regulator-name = "sandbox-voltd0";
|
|
|
|
regulator-min-microvolt = <1100000>;
|
|
|
|
regulator-max-microvolt = <3300000>;
|
|
|
|
};
|
2022-02-21 08:22:39 +00:00
|
|
|
regul1_scmi: reg@1 {
|
2021-03-08 21:38:07 +00:00
|
|
|
reg = <0x1>;
|
|
|
|
regulator-name = "sandbox-voltd1";
|
|
|
|
regulator-min-microvolt = <1800000>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
2020-09-09 16:44:00 +00:00
|
|
|
};
|
2018-09-19 10:43:46 +00:00
|
|
|
};
|
|
|
|
|
2022-09-30 12:04:30 +00:00
|
|
|
fpga {
|
|
|
|
compatible = "sandbox,fpga";
|
|
|
|
};
|
|
|
|
|
2020-01-13 10:35:15 +00:00
|
|
|
pinctrl-gpio {
|
|
|
|
compatible = "sandbox,pinctrl-gpio";
|
|
|
|
|
|
|
|
gpio_a: base-gpios {
|
|
|
|
compatible = "sandbox,gpio";
|
|
|
|
gpio-controller;
|
|
|
|
#gpio-cells = <1>;
|
|
|
|
gpio-bank-name = "a";
|
|
|
|
sandbox,gpio-count = <20>;
|
2020-05-22 09:08:58 +00:00
|
|
|
hog_input_active_low {
|
|
|
|
gpio-hog;
|
|
|
|
input;
|
sandbox, test: change hog gpio
Since commit 9ba84329dc45 ("sandbox, test: add test for GPIO_HOG
function"), the gpio_a 0,1,2 and 3 are used by hog in test.dts.
But 2 leds 'sandbox:red' and 'sandbox:green' are using gpio_a 0
and 1. As hog always request his gpios, the led command on both
led is broken:
=> led sandbox:red
LED 'sandbox:red' not found (err=-16)
The gpio is already requested by hog, so it can't be enabled
for led 'sandbox:red'.
This commit change the gpio used by hog to 10, 11, 12 and 13,
so the led command could be used again with 'sandbox:red' and
'sandbox:green'.
Signed-off-by: Philippe Reynes <philippe.reynes@softathome.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Heiko Schocher <hs@denx.de>
2020-07-24 13:51:53 +00:00
|
|
|
gpios = <10 GPIO_ACTIVE_LOW>;
|
2020-05-22 09:08:58 +00:00
|
|
|
};
|
|
|
|
hog_input_active_high {
|
|
|
|
gpio-hog;
|
|
|
|
input;
|
sandbox, test: change hog gpio
Since commit 9ba84329dc45 ("sandbox, test: add test for GPIO_HOG
function"), the gpio_a 0,1,2 and 3 are used by hog in test.dts.
But 2 leds 'sandbox:red' and 'sandbox:green' are using gpio_a 0
and 1. As hog always request his gpios, the led command on both
led is broken:
=> led sandbox:red
LED 'sandbox:red' not found (err=-16)
The gpio is already requested by hog, so it can't be enabled
for led 'sandbox:red'.
This commit change the gpio used by hog to 10, 11, 12 and 13,
so the led command could be used again with 'sandbox:red' and
'sandbox:green'.
Signed-off-by: Philippe Reynes <philippe.reynes@softathome.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Heiko Schocher <hs@denx.de>
2020-07-24 13:51:53 +00:00
|
|
|
gpios = <11 GPIO_ACTIVE_HIGH>;
|
2020-05-22 09:08:58 +00:00
|
|
|
};
|
|
|
|
hog_output_low {
|
|
|
|
gpio-hog;
|
|
|
|
output-low;
|
sandbox, test: change hog gpio
Since commit 9ba84329dc45 ("sandbox, test: add test for GPIO_HOG
function"), the gpio_a 0,1,2 and 3 are used by hog in test.dts.
But 2 leds 'sandbox:red' and 'sandbox:green' are using gpio_a 0
and 1. As hog always request his gpios, the led command on both
led is broken:
=> led sandbox:red
LED 'sandbox:red' not found (err=-16)
The gpio is already requested by hog, so it can't be enabled
for led 'sandbox:red'.
This commit change the gpio used by hog to 10, 11, 12 and 13,
so the led command could be used again with 'sandbox:red' and
'sandbox:green'.
Signed-off-by: Philippe Reynes <philippe.reynes@softathome.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Heiko Schocher <hs@denx.de>
2020-07-24 13:51:53 +00:00
|
|
|
gpios = <12 GPIO_ACTIVE_HIGH>;
|
2020-05-22 09:08:58 +00:00
|
|
|
};
|
|
|
|
hog_output_high {
|
|
|
|
gpio-hog;
|
|
|
|
output-high;
|
sandbox, test: change hog gpio
Since commit 9ba84329dc45 ("sandbox, test: add test for GPIO_HOG
function"), the gpio_a 0,1,2 and 3 are used by hog in test.dts.
But 2 leds 'sandbox:red' and 'sandbox:green' are using gpio_a 0
and 1. As hog always request his gpios, the led command on both
led is broken:
=> led sandbox:red
LED 'sandbox:red' not found (err=-16)
The gpio is already requested by hog, so it can't be enabled
for led 'sandbox:red'.
This commit change the gpio used by hog to 10, 11, 12 and 13,
so the led command could be used again with 'sandbox:red' and
'sandbox:green'.
Signed-off-by: Philippe Reynes <philippe.reynes@softathome.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Heiko Schocher <hs@denx.de>
2020-07-24 13:51:53 +00:00
|
|
|
gpios = <13 GPIO_ACTIVE_HIGH>;
|
2020-05-22 09:08:58 +00:00
|
|
|
};
|
2020-01-13 10:35:15 +00:00
|
|
|
};
|
2014-02-26 22:59:21 +00:00
|
|
|
|
2020-01-13 10:35:15 +00:00
|
|
|
gpio_b: extra-gpios {
|
|
|
|
compatible = "sandbox,gpio";
|
|
|
|
gpio-controller;
|
|
|
|
#gpio-cells = <5>;
|
|
|
|
gpio-bank-name = "b";
|
|
|
|
sandbox,gpio-count = <10>;
|
|
|
|
};
|
2014-10-14 05:42:11 +00:00
|
|
|
|
2020-01-13 10:35:15 +00:00
|
|
|
gpio_c: pinmux-gpios {
|
|
|
|
compatible = "sandbox,gpio";
|
|
|
|
gpio-controller;
|
|
|
|
#gpio-cells = <2>;
|
|
|
|
gpio-bank-name = "c";
|
|
|
|
sandbox,gpio-count = <10>;
|
|
|
|
};
|
2020-01-13 10:35:14 +00:00
|
|
|
};
|
|
|
|
|
2014-12-10 15:55:55 +00:00
|
|
|
i2c@0 {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <0 1>;
|
2014-12-10 15:55:55 +00:00
|
|
|
compatible = "sandbox,i2c";
|
|
|
|
clock-frequency = <100000>;
|
2021-04-11 07:39:50 +00:00
|
|
|
pinctrl-names = "default";
|
|
|
|
pinctrl-0 = <&pinmux_i2c0_pins>;
|
|
|
|
|
2014-12-10 15:55:55 +00:00
|
|
|
eeprom@2c {
|
2022-05-05 17:11:42 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
2014-12-10 15:55:55 +00:00
|
|
|
reg = <0x2c>;
|
|
|
|
compatible = "i2c-eeprom";
|
2018-11-18 15:14:34 +00:00
|
|
|
sandbox,emul = <&emul_eeprom>;
|
2020-05-28 09:48:55 +00:00
|
|
|
partitions {
|
|
|
|
compatible = "fixed-partitions";
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
|
|
|
bootcount_i2c: bootcount@10 {
|
|
|
|
reg = <10 2>;
|
|
|
|
};
|
|
|
|
};
|
2022-05-05 17:11:42 +00:00
|
|
|
|
|
|
|
eth3_addr: mac-address@24 {
|
|
|
|
reg = <24 6>;
|
|
|
|
};
|
2014-12-10 15:55:55 +00:00
|
|
|
};
|
2015-05-13 11:38:35 +00:00
|
|
|
|
2015-05-22 21:42:17 +00:00
|
|
|
rtc_0: rtc@43 {
|
2022-05-05 17:11:43 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
2015-05-22 21:42:17 +00:00
|
|
|
reg = <0x43>;
|
|
|
|
compatible = "sandbox-rtc";
|
2018-11-18 15:14:34 +00:00
|
|
|
sandbox,emul = <&emul0>;
|
2022-05-05 17:11:43 +00:00
|
|
|
|
|
|
|
eth4_addr: mac-address@40 {
|
|
|
|
reg = <0x40 6>;
|
|
|
|
};
|
2015-05-22 21:42:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
rtc_1: rtc@61 {
|
|
|
|
reg = <0x61>;
|
|
|
|
compatible = "sandbox-rtc";
|
2018-11-18 15:14:34 +00:00
|
|
|
sandbox,emul = <&emul1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
i2c_emul: emul {
|
|
|
|
reg = <0xff>;
|
|
|
|
compatible = "sandbox,i2c-emul-parent";
|
|
|
|
emul_eeprom: emul-eeprom {
|
|
|
|
compatible = "sandbox,i2c-eeprom";
|
|
|
|
sandbox,filename = "i2c.bin";
|
|
|
|
sandbox,size = <256>;
|
|
|
|
};
|
|
|
|
emul0: emul0 {
|
2021-02-03 13:01:17 +00:00
|
|
|
compatible = "sandbox,i2c-rtc-emul";
|
2018-11-18 15:14:34 +00:00
|
|
|
};
|
|
|
|
emul1: emull {
|
2021-02-03 13:01:17 +00:00
|
|
|
compatible = "sandbox,i2c-rtc-emul";
|
2015-05-22 21:42:17 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2015-05-13 11:38:35 +00:00
|
|
|
sandbox_pmic: sandbox_pmic {
|
|
|
|
reg = <0x40>;
|
2018-11-18 15:14:34 +00:00
|
|
|
sandbox,emul = <&emul_pmic0>;
|
2015-05-13 11:38:35 +00:00
|
|
|
};
|
2018-05-15 14:26:40 +00:00
|
|
|
|
|
|
|
mc34708: pmic@41 {
|
|
|
|
reg = <0x41>;
|
2018-11-18 15:14:34 +00:00
|
|
|
sandbox,emul = <&emul_pmic1>;
|
2018-05-15 14:26:40 +00:00
|
|
|
};
|
2014-12-10 15:55:55 +00:00
|
|
|
};
|
|
|
|
|
2018-12-14 20:14:29 +00:00
|
|
|
bootcount@0 {
|
|
|
|
compatible = "u-boot,bootcount-rtc";
|
|
|
|
rtc = <&rtc_1>;
|
|
|
|
offset = <0x13>;
|
|
|
|
};
|
|
|
|
|
2020-05-28 09:48:55 +00:00
|
|
|
bootcount {
|
|
|
|
compatible = "u-boot,bootcount-i2c-eeprom";
|
|
|
|
i2c-eeprom = <&bootcount_i2c>;
|
|
|
|
};
|
|
|
|
|
2021-06-10 12:40:38 +00:00
|
|
|
bootcount_4@0 {
|
|
|
|
compatible = "u-boot,bootcount-syscon";
|
|
|
|
syscon = <&syscon0>;
|
|
|
|
reg = <0x0 0x04>, <0x0 0x04>;
|
|
|
|
reg-names = "syscon_reg", "offset";
|
|
|
|
};
|
|
|
|
|
|
|
|
bootcount_2@0 {
|
|
|
|
compatible = "u-boot,bootcount-syscon";
|
|
|
|
syscon = <&syscon0>;
|
|
|
|
reg = <0x0 0x04>, <0x0 0x02> ;
|
|
|
|
reg-names = "syscon_reg", "offset";
|
|
|
|
};
|
|
|
|
|
2021-02-18 10:33:18 +00:00
|
|
|
adc: adc@0 {
|
2015-10-27 12:08:06 +00:00
|
|
|
compatible = "sandbox,adc";
|
2021-02-18 10:33:18 +00:00
|
|
|
#io-channel-cells = <1>;
|
2015-10-27 12:08:06 +00:00
|
|
|
vdd-supply = <&buck2>;
|
|
|
|
vss-microvolts = <0>;
|
|
|
|
};
|
|
|
|
|
2021-10-23 14:58:02 +00:00
|
|
|
iommu: iommu@0 {
|
|
|
|
compatible = "sandbox,iommu";
|
|
|
|
#iommu-cells = <0>;
|
|
|
|
};
|
|
|
|
|
2020-02-06 16:55:00 +00:00
|
|
|
irq: irq {
|
2019-12-07 04:41:59 +00:00
|
|
|
compatible = "sandbox,irq";
|
2020-02-06 16:55:00 +00:00
|
|
|
interrupt-controller;
|
|
|
|
#interrupt-cells = <2>;
|
2019-12-07 04:41:59 +00:00
|
|
|
};
|
|
|
|
|
2016-01-19 02:52:26 +00:00
|
|
|
lcd {
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-all;
|
2016-01-19 02:52:26 +00:00
|
|
|
compatible = "sandbox,lcd-sdl";
|
2021-04-11 07:39:50 +00:00
|
|
|
pinctrl-names = "default";
|
|
|
|
pinctrl-0 = <&pinmux_lcd_pins>;
|
2016-01-19 02:52:26 +00:00
|
|
|
xres = <1366>;
|
|
|
|
yres = <768>;
|
|
|
|
};
|
|
|
|
|
2015-07-06 18:54:34 +00:00
|
|
|
leds {
|
|
|
|
compatible = "gpio-leds";
|
|
|
|
|
|
|
|
iracibble {
|
|
|
|
gpios = <&gpio_a 1 0>;
|
|
|
|
label = "sandbox:red";
|
|
|
|
};
|
|
|
|
|
|
|
|
martinet {
|
|
|
|
gpios = <&gpio_a 2 0>;
|
|
|
|
label = "sandbox:green";
|
|
|
|
};
|
2018-04-11 09:16:29 +00:00
|
|
|
|
|
|
|
default_on {
|
|
|
|
gpios = <&gpio_a 5 0>;
|
|
|
|
label = "sandbox:default_on";
|
|
|
|
default-state = "on";
|
|
|
|
};
|
|
|
|
|
|
|
|
default_off {
|
|
|
|
gpios = <&gpio_a 6 0>;
|
2020-09-14 15:02:03 +00:00
|
|
|
/* label intentionally omitted */
|
2018-04-11 09:16:29 +00:00
|
|
|
default-state = "off";
|
|
|
|
};
|
2015-07-06 18:54:34 +00:00
|
|
|
};
|
|
|
|
|
2022-07-04 09:00:25 +00:00
|
|
|
wdt-gpio-toggle {
|
2021-08-19 09:57:05 +00:00
|
|
|
gpios = <&gpio_a 7 0>;
|
|
|
|
compatible = "linux,wdt-gpio";
|
2021-08-19 09:57:06 +00:00
|
|
|
hw_margin_ms = <100>;
|
2022-07-04 09:00:25 +00:00
|
|
|
hw_algo = "toggle";
|
|
|
|
always-running;
|
|
|
|
};
|
|
|
|
|
|
|
|
wdt-gpio-level {
|
|
|
|
gpios = <&gpio_a 7 0>;
|
|
|
|
compatible = "linux,wdt-gpio";
|
|
|
|
hw_margin_ms = <100>;
|
|
|
|
hw_algo = "level";
|
2021-08-19 09:57:05 +00:00
|
|
|
always-running;
|
|
|
|
};
|
|
|
|
|
2016-05-16 23:41:37 +00:00
|
|
|
mbox: mbox {
|
|
|
|
compatible = "sandbox,mbox";
|
|
|
|
#mbox-cells = <1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
mbox-test {
|
|
|
|
compatible = "sandbox,mbox-test";
|
|
|
|
mboxes = <&mbox 100>, <&mbox 1>;
|
|
|
|
mbox-names = "other", "test";
|
|
|
|
};
|
|
|
|
|
2019-08-27 08:17:03 +00:00
|
|
|
cpus {
|
2021-08-28 09:42:08 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2020-09-28 14:52:23 +00:00
|
|
|
timebase-frequency = <2000000>;
|
2021-08-28 09:42:08 +00:00
|
|
|
cpu1: cpu@1 {
|
|
|
|
device_type = "cpu";
|
|
|
|
reg = <0x1>;
|
2020-09-28 14:52:23 +00:00
|
|
|
timebase-frequency = <3000000>;
|
2019-08-27 08:17:03 +00:00
|
|
|
compatible = "sandbox,cpu_sandbox";
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-all;
|
2019-08-27 08:17:03 +00:00
|
|
|
};
|
2018-08-06 08:23:44 +00:00
|
|
|
|
2021-08-28 09:42:08 +00:00
|
|
|
cpu2: cpu@2 {
|
|
|
|
device_type = "cpu";
|
|
|
|
reg = <0x2>;
|
2019-08-27 08:17:03 +00:00
|
|
|
compatible = "sandbox,cpu_sandbox";
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-all;
|
2019-08-27 08:17:03 +00:00
|
|
|
};
|
2018-08-06 08:23:44 +00:00
|
|
|
|
2021-08-28 09:42:08 +00:00
|
|
|
cpu3: cpu@3 {
|
|
|
|
device_type = "cpu";
|
|
|
|
reg = <0x3>;
|
2019-08-27 08:17:03 +00:00
|
|
|
compatible = "sandbox,cpu_sandbox";
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-all;
|
2019-08-27 08:17:03 +00:00
|
|
|
};
|
2018-08-06 08:23:44 +00:00
|
|
|
};
|
|
|
|
|
2020-07-16 04:39:58 +00:00
|
|
|
chipid: chipid {
|
|
|
|
compatible = "sandbox,soc";
|
|
|
|
};
|
|
|
|
|
2018-12-10 17:37:34 +00:00
|
|
|
i2s: i2s {
|
|
|
|
compatible = "sandbox,i2s";
|
|
|
|
#sound-dai-cells = <1>;
|
2019-02-17 03:24:56 +00:00
|
|
|
sandbox,silent; /* Don't emit sounds while testing */
|
2018-12-10 17:37:34 +00:00
|
|
|
};
|
|
|
|
|
2019-07-05 07:33:57 +00:00
|
|
|
nop-test_0 {
|
|
|
|
compatible = "sandbox,nop_sandbox1";
|
|
|
|
nop-test_1 {
|
|
|
|
compatible = "sandbox,nop_sandbox2";
|
|
|
|
bind = "True";
|
|
|
|
};
|
|
|
|
nop-test_2 {
|
|
|
|
compatible = "sandbox,nop_sandbox2";
|
|
|
|
bind = "False";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2022-10-20 13:30:46 +00:00
|
|
|
memory-controller {
|
|
|
|
compatible = "sandbox,memory";
|
|
|
|
};
|
|
|
|
|
2018-07-31 12:24:14 +00:00
|
|
|
misc-test {
|
2022-05-05 17:11:44 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
2018-07-31 12:24:14 +00:00
|
|
|
compatible = "sandbox,misc_sandbox";
|
2022-05-05 17:11:44 +00:00
|
|
|
|
|
|
|
eth5_addr: mac-address@10 {
|
|
|
|
reg = <0x10 6>;
|
|
|
|
};
|
2018-07-31 12:24:14 +00:00
|
|
|
};
|
|
|
|
|
2017-04-24 02:02:07 +00:00
|
|
|
mmc2 {
|
|
|
|
compatible = "sandbox,mmc";
|
2021-07-05 22:32:58 +00:00
|
|
|
non-removable;
|
2017-04-24 02:02:07 +00:00
|
|
|
};
|
|
|
|
|
2022-04-25 05:31:24 +00:00
|
|
|
/* This is used for the bootdev tests */
|
2017-04-24 02:02:07 +00:00
|
|
|
mmc1 {
|
|
|
|
compatible = "sandbox,mmc";
|
2022-04-25 05:31:24 +00:00
|
|
|
filename = "mmc1.img";
|
2017-04-24 02:02:07 +00:00
|
|
|
};
|
|
|
|
|
2022-04-25 05:31:24 +00:00
|
|
|
/* This is used for the fastboot tests */
|
2022-10-21 12:46:05 +00:00
|
|
|
mmc0: mmc0 {
|
2015-07-06 18:54:32 +00:00
|
|
|
compatible = "sandbox,mmc";
|
|
|
|
};
|
|
|
|
|
2022-10-21 00:23:20 +00:00
|
|
|
/* This is used for VBE VPL tests */
|
|
|
|
mmc3 {
|
|
|
|
status = "disabled";
|
|
|
|
compatible = "sandbox,mmc";
|
|
|
|
filename = "image.bin";
|
|
|
|
non-removable;
|
|
|
|
};
|
|
|
|
|
2023-01-06 14:52:41 +00:00
|
|
|
/* This is used for bootstd bootmenu tests */
|
|
|
|
mmc4 {
|
|
|
|
status = "disabled";
|
|
|
|
compatible = "sandbox,mmc";
|
|
|
|
filename = "mmc4.img";
|
|
|
|
};
|
|
|
|
|
2023-08-24 19:55:41 +00:00
|
|
|
/* This is used for ChromiumOS tests */
|
|
|
|
mmc5 {
|
|
|
|
status = "disabled";
|
|
|
|
compatible = "sandbox,mmc";
|
|
|
|
filename = "mmc5.img";
|
|
|
|
};
|
|
|
|
|
2019-02-17 03:24:50 +00:00
|
|
|
pch {
|
|
|
|
compatible = "sandbox,pch";
|
|
|
|
};
|
|
|
|
|
2020-02-11 17:41:23 +00:00
|
|
|
pci0: pci@0 {
|
2015-03-05 19:25:34 +00:00
|
|
|
compatible = "sandbox,pci";
|
|
|
|
device_type = "pci";
|
2020-02-11 17:41:23 +00:00
|
|
|
bus-range = <0x00 0xff>;
|
2015-03-05 19:25:34 +00:00
|
|
|
#address-cells = <3>;
|
|
|
|
#size-cells = <2>;
|
2019-09-25 14:56:08 +00:00
|
|
|
ranges = <0x02000000 0 0x10000000 0x10000000 0 0x2000000
|
2015-03-05 19:25:34 +00:00
|
|
|
0x01000000 0 0x20000000 0x20000000 0 0x2000>;
|
2023-01-21 19:27:57 +00:00
|
|
|
iommu-map = <0x0010 &iommu 0 1>;
|
|
|
|
iommu-map-mask = <0xfffffff8>;
|
2018-08-03 08:14:39 +00:00
|
|
|
pci@0,0 {
|
|
|
|
compatible = "pci-generic";
|
|
|
|
reg = <0x0000 0 0 0 0>;
|
pci: sandbox: Move the emulators into their own node
Sandbox pci works using emulation drivers which are currently children of
the pci device:
pci-controller {
pci@1f,0 {
compatible = "pci-generic";
reg = <0xf800 0 0 0 0>;
emul@1f,0 {
compatible = "sandbox,swap-case";
};
};
};
In this case the emulation device is attached to pci device on address
f800 (device 1f, function 0) and provides the swap-case functionality.
However this is not ideal, since every device on a PCI bus has a child
device. This is only really the case for sandbox, but we want to avoid
special-case code for sandbox.
Worse, child devices cannot be probed before their parents. This forces
us to use 'find' rather than 'get' to obtain the emulator device. In fact
the emulator devices are never probed. There is code in
sandbox_pci_emul_post_probe() which tries to track when emulators are
active, but at present this does not work.
A better approach seems to be to add a separate node elsewhere in the
device tree, an 'emulation parent'. This could be given a bogus address
(such as -1) to hide the emulators away from the 'pci' command, but it
seems better to keep it at the root node to avoid such hacks.
Then we can use a phandle to point from the device to the correct
emulator, and only on sandbox. The code to find an emulator does not
interfere with normal pci operation.
Add a new UCLASS_PCI_EMUL_PARENT uclass which allows finding an emulator
given a bus, and finding a bus given an emulator. Update the existing
device trees and the code for finding an emulator.
This brings PCI emulators more into line with I2C.
Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Bin Meng <bmeng.cn@gmail.com>
[bmeng: fix 3 typos in the commit message;
encode bus number in the labels of swap_case_emul nodes;
mention commit 4345998ae9df in sandbox_pci_get_emul()]
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
2019-09-25 14:56:10 +00:00
|
|
|
sandbox,emul = <&swap_case_emul0_0>;
|
2018-08-03 08:14:39 +00:00
|
|
|
};
|
2019-06-07 08:24:24 +00:00
|
|
|
pci@1,0 {
|
|
|
|
compatible = "pci-generic";
|
2019-09-15 18:08:58 +00:00
|
|
|
/* reg 0 is at 0x14, using FDT_PCI_SPACE_MEM32 */
|
2023-09-26 14:14:58 +00:00
|
|
|
reg = <0x02000814 0 0 0x80 0
|
|
|
|
0x01000810 0 0 0xc0 0>;
|
pci: sandbox: Move the emulators into their own node
Sandbox pci works using emulation drivers which are currently children of
the pci device:
pci-controller {
pci@1f,0 {
compatible = "pci-generic";
reg = <0xf800 0 0 0 0>;
emul@1f,0 {
compatible = "sandbox,swap-case";
};
};
};
In this case the emulation device is attached to pci device on address
f800 (device 1f, function 0) and provides the swap-case functionality.
However this is not ideal, since every device on a PCI bus has a child
device. This is only really the case for sandbox, but we want to avoid
special-case code for sandbox.
Worse, child devices cannot be probed before their parents. This forces
us to use 'find' rather than 'get' to obtain the emulator device. In fact
the emulator devices are never probed. There is code in
sandbox_pci_emul_post_probe() which tries to track when emulators are
active, but at present this does not work.
A better approach seems to be to add a separate node elsewhere in the
device tree, an 'emulation parent'. This could be given a bogus address
(such as -1) to hide the emulators away from the 'pci' command, but it
seems better to keep it at the root node to avoid such hacks.
Then we can use a phandle to point from the device to the correct
emulator, and only on sandbox. The code to find an emulator does not
interfere with normal pci operation.
Add a new UCLASS_PCI_EMUL_PARENT uclass which allows finding an emulator
given a bus, and finding a bus given an emulator. Update the existing
device trees and the code for finding an emulator.
This brings PCI emulators more into line with I2C.
Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Bin Meng <bmeng.cn@gmail.com>
[bmeng: fix 3 typos in the commit message;
encode bus number in the labels of swap_case_emul nodes;
mention commit 4345998ae9df in sandbox_pci_get_emul()]
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
2019-09-25 14:56:10 +00:00
|
|
|
sandbox,emul = <&swap_case_emul0_1>;
|
2019-06-07 08:24:24 +00:00
|
|
|
};
|
2019-12-07 04:41:57 +00:00
|
|
|
p2sb-pci@2,0 {
|
|
|
|
compatible = "sandbox,p2sb";
|
|
|
|
reg = <0x02001010 0 0 0 0>;
|
|
|
|
sandbox,emul = <&p2sb_emul>;
|
|
|
|
|
|
|
|
adder {
|
|
|
|
intel,p2sb-port-id = <3>;
|
|
|
|
compatible = "sandbox,adder";
|
|
|
|
};
|
|
|
|
};
|
2019-12-07 04:41:54 +00:00
|
|
|
pci@1e,0 {
|
|
|
|
compatible = "sandbox,pmc";
|
|
|
|
reg = <0xf000 0 0 0 0>;
|
|
|
|
sandbox,emul = <&pmc_emul1e>;
|
|
|
|
acpi-base = <0x400>;
|
|
|
|
gpe0-dwx-mask = <0xf>;
|
|
|
|
gpe0-dwx-shift-base = <4>;
|
|
|
|
gpe0-dw = <6 7 9>;
|
|
|
|
gpe0-sts = <0x20>;
|
|
|
|
gpe0-en = <0x30>;
|
|
|
|
};
|
2015-03-05 19:25:34 +00:00
|
|
|
pci@1f,0 {
|
|
|
|
compatible = "pci-generic";
|
2019-09-15 18:08:58 +00:00
|
|
|
/* reg 0 is at 0x10, using FDT_PCI_SPACE_IO */
|
2023-09-26 14:14:58 +00:00
|
|
|
reg = <0x0100f810 0 0 0x100 0>;
|
pci: sandbox: Move the emulators into their own node
Sandbox pci works using emulation drivers which are currently children of
the pci device:
pci-controller {
pci@1f,0 {
compatible = "pci-generic";
reg = <0xf800 0 0 0 0>;
emul@1f,0 {
compatible = "sandbox,swap-case";
};
};
};
In this case the emulation device is attached to pci device on address
f800 (device 1f, function 0) and provides the swap-case functionality.
However this is not ideal, since every device on a PCI bus has a child
device. This is only really the case for sandbox, but we want to avoid
special-case code for sandbox.
Worse, child devices cannot be probed before their parents. This forces
us to use 'find' rather than 'get' to obtain the emulator device. In fact
the emulator devices are never probed. There is code in
sandbox_pci_emul_post_probe() which tries to track when emulators are
active, but at present this does not work.
A better approach seems to be to add a separate node elsewhere in the
device tree, an 'emulation parent'. This could be given a bogus address
(such as -1) to hide the emulators away from the 'pci' command, but it
seems better to keep it at the root node to avoid such hacks.
Then we can use a phandle to point from the device to the correct
emulator, and only on sandbox. The code to find an emulator does not
interfere with normal pci operation.
Add a new UCLASS_PCI_EMUL_PARENT uclass which allows finding an emulator
given a bus, and finding a bus given an emulator. Update the existing
device trees and the code for finding an emulator.
This brings PCI emulators more into line with I2C.
Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Bin Meng <bmeng.cn@gmail.com>
[bmeng: fix 3 typos in the commit message;
encode bus number in the labels of swap_case_emul nodes;
mention commit 4345998ae9df in sandbox_pci_get_emul()]
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
2019-09-25 14:56:10 +00:00
|
|
|
sandbox,emul = <&swap_case_emul0_1f>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
pci-emul0 {
|
|
|
|
compatible = "sandbox,pci-emul-parent";
|
|
|
|
swap_case_emul0_0: emul0@0,0 {
|
|
|
|
compatible = "sandbox,swap-case";
|
|
|
|
};
|
|
|
|
swap_case_emul0_1: emul0@1,0 {
|
|
|
|
compatible = "sandbox,swap-case";
|
|
|
|
use-ea;
|
|
|
|
};
|
|
|
|
swap_case_emul0_1f: emul0@1f,0 {
|
|
|
|
compatible = "sandbox,swap-case";
|
2015-03-05 19:25:34 +00:00
|
|
|
};
|
2019-12-07 04:41:57 +00:00
|
|
|
p2sb_emul: emul@2,0 {
|
|
|
|
compatible = "sandbox,p2sb-emul";
|
|
|
|
};
|
2019-12-07 04:41:54 +00:00
|
|
|
pmc_emul1e: emul@1e,0 {
|
|
|
|
compatible = "sandbox,pmc-emul";
|
|
|
|
};
|
2015-03-05 19:25:34 +00:00
|
|
|
};
|
|
|
|
|
2020-02-11 17:41:23 +00:00
|
|
|
pci1: pci@1 {
|
2018-08-03 08:14:41 +00:00
|
|
|
compatible = "sandbox,pci";
|
|
|
|
device_type = "pci";
|
2020-02-11 17:41:23 +00:00
|
|
|
bus-range = <0x00 0xff>;
|
2018-08-03 08:14:41 +00:00
|
|
|
#address-cells = <3>;
|
|
|
|
#size-cells = <2>;
|
2019-10-20 00:10:20 +00:00
|
|
|
ranges = <0x02000000 0 0x30000000 0x30000000 0 0x2000 // MEM0
|
2022-04-21 16:11:09 +00:00
|
|
|
0x02000000 0 0x31000000 0x3e000000 0 0x2000 // MEM1
|
2019-10-20 00:10:20 +00:00
|
|
|
0x01000000 0 0x40000000 0x40000000 0 0x2000>;
|
2018-08-03 08:14:47 +00:00
|
|
|
sandbox,dev-info = <0x08 0x00 0x1234 0x5678
|
2018-10-10 19:27:08 +00:00
|
|
|
0x0c 0x00 0x1234 0x5678
|
|
|
|
0x10 0x00 0x1234 0x5678>;
|
|
|
|
pci@10,0 {
|
|
|
|
reg = <0x8000 0 0 0 0>;
|
|
|
|
};
|
2018-08-03 08:14:41 +00:00
|
|
|
};
|
|
|
|
|
2020-02-11 17:41:23 +00:00
|
|
|
pci2: pci@2 {
|
2018-08-03 08:14:50 +00:00
|
|
|
compatible = "sandbox,pci";
|
|
|
|
device_type = "pci";
|
2020-02-11 17:41:23 +00:00
|
|
|
bus-range = <0x00 0xff>;
|
2018-08-03 08:14:50 +00:00
|
|
|
#address-cells = <3>;
|
|
|
|
#size-cells = <2>;
|
|
|
|
ranges = <0x02000000 0 0x50000000 0x50000000 0 0x2000
|
|
|
|
0x01000000 0 0x60000000 0x60000000 0 0x2000>;
|
|
|
|
sandbox,dev-info = <0x08 0x00 0x1234 0x5678>;
|
|
|
|
pci@1f,0 {
|
|
|
|
compatible = "pci-generic";
|
|
|
|
reg = <0xf800 0 0 0 0>;
|
pci: sandbox: Move the emulators into their own node
Sandbox pci works using emulation drivers which are currently children of
the pci device:
pci-controller {
pci@1f,0 {
compatible = "pci-generic";
reg = <0xf800 0 0 0 0>;
emul@1f,0 {
compatible = "sandbox,swap-case";
};
};
};
In this case the emulation device is attached to pci device on address
f800 (device 1f, function 0) and provides the swap-case functionality.
However this is not ideal, since every device on a PCI bus has a child
device. This is only really the case for sandbox, but we want to avoid
special-case code for sandbox.
Worse, child devices cannot be probed before their parents. This forces
us to use 'find' rather than 'get' to obtain the emulator device. In fact
the emulator devices are never probed. There is code in
sandbox_pci_emul_post_probe() which tries to track when emulators are
active, but at present this does not work.
A better approach seems to be to add a separate node elsewhere in the
device tree, an 'emulation parent'. This could be given a bogus address
(such as -1) to hide the emulators away from the 'pci' command, but it
seems better to keep it at the root node to avoid such hacks.
Then we can use a phandle to point from the device to the correct
emulator, and only on sandbox. The code to find an emulator does not
interfere with normal pci operation.
Add a new UCLASS_PCI_EMUL_PARENT uclass which allows finding an emulator
given a bus, and finding a bus given an emulator. Update the existing
device trees and the code for finding an emulator.
This brings PCI emulators more into line with I2C.
Signed-off-by: Simon Glass <sjg@chromium.org>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
Tested-by: Bin Meng <bmeng.cn@gmail.com>
[bmeng: fix 3 typos in the commit message;
encode bus number in the labels of swap_case_emul nodes;
mention commit 4345998ae9df in sandbox_pci_get_emul()]
Signed-off-by: Bin Meng <bmeng.cn@gmail.com>
2019-09-25 14:56:10 +00:00
|
|
|
sandbox,emul = <&swap_case_emul2_1f>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
pci-emul2 {
|
|
|
|
compatible = "sandbox,pci-emul-parent";
|
|
|
|
swap_case_emul2_1f: emul2@1f,0 {
|
|
|
|
compatible = "sandbox,swap-case";
|
2018-08-03 08:14:50 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2019-04-27 08:15:23 +00:00
|
|
|
pci_ep: pci_ep {
|
|
|
|
compatible = "sandbox,pci_ep";
|
|
|
|
};
|
|
|
|
|
2017-04-24 02:10:44 +00:00
|
|
|
probing {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
test1 {
|
|
|
|
compatible = "denx,u-boot-probe-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
test2 {
|
|
|
|
compatible = "denx,u-boot-probe-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
test3 {
|
|
|
|
compatible = "denx,u-boot-probe-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
test4 {
|
|
|
|
compatible = "denx,u-boot-probe-test";
|
2018-11-29 09:57:37 +00:00
|
|
|
first-syscon = <&syscon0>;
|
|
|
|
second-sys-ctrl = <&another_system_controller>;
|
2019-03-07 08:57:13 +00:00
|
|
|
third-syscon = <&syscon2>;
|
2017-04-24 02:10:44 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2016-07-13 19:45:31 +00:00
|
|
|
pwrdom: power-domain {
|
|
|
|
compatible = "sandbox,power-domain";
|
|
|
|
#power-domain-cells = <1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
power-domain-test {
|
|
|
|
compatible = "sandbox,power-domain-test";
|
|
|
|
power-domains = <&pwrdom 2>;
|
|
|
|
};
|
|
|
|
|
2018-10-01 18:22:40 +00:00
|
|
|
pwm: pwm {
|
2017-04-17 03:01:11 +00:00
|
|
|
compatible = "sandbox,pwm";
|
2018-10-01 18:22:40 +00:00
|
|
|
#pwm-cells = <2>;
|
2021-04-11 07:39:50 +00:00
|
|
|
pinctrl-names = "default";
|
|
|
|
pinctrl-0 = <&pinmux_pwm_pins>;
|
2017-04-17 03:01:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
pwm2 {
|
|
|
|
compatible = "sandbox,pwm";
|
2018-10-01 18:22:40 +00:00
|
|
|
#pwm-cells = <2>;
|
2017-04-17 03:01:11 +00:00
|
|
|
};
|
|
|
|
|
2015-07-06 18:54:31 +00:00
|
|
|
ram {
|
|
|
|
compatible = "sandbox,ram";
|
|
|
|
};
|
|
|
|
|
2015-07-06 18:54:29 +00:00
|
|
|
reset@0 {
|
|
|
|
compatible = "sandbox,warm-reset";
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-some-ram;
|
2015-07-06 18:54:29 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
reset@1 {
|
|
|
|
compatible = "sandbox,reset";
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-some-ram;
|
2015-07-06 18:54:29 +00:00
|
|
|
};
|
|
|
|
|
2016-06-17 15:43:59 +00:00
|
|
|
resetc: reset-ctl {
|
|
|
|
compatible = "sandbox,reset-ctl";
|
|
|
|
#reset-cells = <1>;
|
|
|
|
};
|
|
|
|
|
|
|
|
reset-ctl-test {
|
|
|
|
compatible = "sandbox,reset-ctl-test";
|
2021-04-20 08:42:25 +00:00
|
|
|
resets = <&resetc 100>, <&resetc 2>, <&resetc 20>, <&resetc 40>;
|
|
|
|
reset-names = "other", "test", "test2", "test3";
|
2016-06-17 15:43:59 +00:00
|
|
|
};
|
|
|
|
|
2019-12-28 18:28:31 +00:00
|
|
|
rng {
|
|
|
|
compatible = "sandbox,sandbox-rng";
|
|
|
|
};
|
|
|
|
|
2015-09-17 20:42:41 +00:00
|
|
|
rproc_1: rproc@1 {
|
|
|
|
compatible = "sandbox,test-processor";
|
|
|
|
remoteproc-name = "remoteproc-test-dev1";
|
|
|
|
};
|
|
|
|
|
|
|
|
rproc_2: rproc@2 {
|
|
|
|
compatible = "sandbox,test-processor";
|
|
|
|
internal-memory-mapped;
|
|
|
|
remoteproc-name = "remoteproc-test-dev2";
|
|
|
|
};
|
|
|
|
|
2018-10-01 18:22:40 +00:00
|
|
|
panel {
|
|
|
|
compatible = "simple-panel";
|
|
|
|
backlight = <&backlight 0 100>;
|
|
|
|
};
|
|
|
|
|
2022-09-21 14:21:47 +00:00
|
|
|
scsi {
|
|
|
|
compatible = "sandbox,scsi";
|
|
|
|
sandbox,filepath = "scsi.img";
|
|
|
|
};
|
|
|
|
|
2018-07-01 23:57:59 +00:00
|
|
|
smem@0 {
|
|
|
|
compatible = "sandbox,smem";
|
|
|
|
};
|
|
|
|
|
2018-12-10 17:37:36 +00:00
|
|
|
sound {
|
|
|
|
compatible = "sandbox,sound";
|
|
|
|
cpu {
|
|
|
|
sound-dai = <&i2s 0>;
|
|
|
|
};
|
|
|
|
|
|
|
|
codec {
|
|
|
|
sound-dai = <&audio 0>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2014-10-14 05:42:11 +00:00
|
|
|
spi@0 {
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <0 1>;
|
2014-10-14 05:42:11 +00:00
|
|
|
compatible = "sandbox,spi";
|
2020-12-14 17:06:47 +00:00
|
|
|
cs-gpios = <0>, <0>, <&gpio_a 0>;
|
2021-04-11 07:39:50 +00:00
|
|
|
pinctrl-names = "default";
|
|
|
|
pinctrl-0 = <&pinmux_spi0_pins>;
|
|
|
|
|
2014-10-14 05:42:11 +00:00
|
|
|
spi.bin@0 {
|
|
|
|
reg = <0>;
|
2019-02-10 10:16:20 +00:00
|
|
|
compatible = "spansion,m25p16", "jedec,spi-nor";
|
2014-10-14 05:42:11 +00:00
|
|
|
spi-max-frequency = <40000000>;
|
|
|
|
sandbox,filename = "spi.bin";
|
|
|
|
};
|
2020-12-14 17:06:47 +00:00
|
|
|
spi.bin@1 {
|
|
|
|
reg = <1>;
|
|
|
|
compatible = "spansion,m25p16", "jedec,spi-nor";
|
|
|
|
spi-max-frequency = <50000000>;
|
|
|
|
sandbox,filename = "spi.bin";
|
|
|
|
spi-cpol;
|
|
|
|
spi-cpha;
|
|
|
|
};
|
2014-10-14 05:42:11 +00:00
|
|
|
};
|
|
|
|
|
2018-11-29 09:57:37 +00:00
|
|
|
syscon0: syscon@0 {
|
2015-07-06 18:54:35 +00:00
|
|
|
compatible = "sandbox,syscon0";
|
2018-10-04 07:00:40 +00:00
|
|
|
reg = <0x10 16>;
|
2015-07-06 18:54:35 +00:00
|
|
|
};
|
|
|
|
|
2018-11-29 09:57:37 +00:00
|
|
|
another_system_controller: syscon@1 {
|
2015-07-06 18:54:35 +00:00
|
|
|
compatible = "sandbox,syscon1";
|
2015-07-06 18:54:36 +00:00
|
|
|
reg = <0x20 5
|
|
|
|
0x28 6
|
|
|
|
0x30 7
|
|
|
|
0x38 8>;
|
2015-07-06 18:54:35 +00:00
|
|
|
};
|
|
|
|
|
2019-03-07 08:57:13 +00:00
|
|
|
syscon2: syscon@2 {
|
2018-04-23 04:26:53 +00:00
|
|
|
compatible = "simple-mfd", "syscon";
|
|
|
|
reg = <0x40 5
|
|
|
|
0x48 6
|
|
|
|
0x50 7
|
|
|
|
0x58 8>;
|
|
|
|
};
|
|
|
|
|
2020-10-16 10:46:34 +00:00
|
|
|
syscon3: syscon@3 {
|
|
|
|
compatible = "simple-mfd", "syscon";
|
|
|
|
reg = <0x000100 0x10>;
|
|
|
|
|
|
|
|
muxcontroller0: a-mux-controller {
|
|
|
|
compatible = "mmio-mux";
|
|
|
|
#mux-control-cells = <1>;
|
|
|
|
|
|
|
|
mux-reg-masks = <0x0 0x30>, /* 0: reg 0x0, bits 5:4 */
|
|
|
|
<0xc 0x1E>, /* 1: reg 0xc, bits 4:1 */
|
|
|
|
<0x4 0xFF>; /* 2: reg 0x4, bits 7:0 */
|
|
|
|
idle-states = <MUX_IDLE_AS_IS>, <0x02>, <0x73>;
|
|
|
|
u-boot,mux-autoprobe;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
muxcontroller1: emul-mux-controller {
|
|
|
|
compatible = "mux-emul";
|
|
|
|
#mux-control-cells = <0>;
|
|
|
|
u-boot,mux-autoprobe;
|
|
|
|
idle-state = <0xabcd>;
|
|
|
|
};
|
|
|
|
|
2020-12-17 04:20:27 +00:00
|
|
|
testfdtm0 {
|
|
|
|
compatible = "denx,u-boot-fdtm-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
testfdtm1: testfdtm1 {
|
|
|
|
compatible = "denx,u-boot-fdtm-test";
|
|
|
|
};
|
|
|
|
|
|
|
|
testfdtm2 {
|
|
|
|
compatible = "denx,u-boot-fdtm-test";
|
|
|
|
};
|
|
|
|
|
2020-09-28 14:52:23 +00:00
|
|
|
timer@0 {
|
2015-12-11 08:27:34 +00:00
|
|
|
compatible = "sandbox,timer";
|
|
|
|
clock-frequency = <1000000>;
|
|
|
|
};
|
|
|
|
|
2020-09-28 14:52:23 +00:00
|
|
|
timer@1 {
|
|
|
|
compatible = "sandbox,timer";
|
|
|
|
sandbox,timebase-frequency-fallback;
|
|
|
|
};
|
|
|
|
|
2018-05-15 09:57:27 +00:00
|
|
|
tpm2 {
|
|
|
|
compatible = "sandbox,tpm2";
|
|
|
|
};
|
|
|
|
|
2023-02-21 13:24:51 +00:00
|
|
|
tpm {
|
|
|
|
compatible = "google,sandbox-tpm";
|
|
|
|
};
|
|
|
|
|
2015-05-22 21:42:15 +00:00
|
|
|
uart0: serial {
|
|
|
|
compatible = "sandbox,serial";
|
2023-02-13 15:56:33 +00:00
|
|
|
bootph-all;
|
2021-04-11 07:39:50 +00:00
|
|
|
pinctrl-names = "default";
|
|
|
|
pinctrl-0 = <&pinmux_uart0_pins>;
|
2015-03-22 22:09:15 +00:00
|
|
|
};
|
|
|
|
|
2015-03-25 18:23:05 +00:00
|
|
|
usb_0: usb@0 {
|
|
|
|
compatible = "sandbox,usb";
|
|
|
|
status = "disabled";
|
|
|
|
hub {
|
|
|
|
compatible = "sandbox,usb-hub";
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
|
|
|
flash-stick {
|
|
|
|
reg = <0>;
|
|
|
|
compatible = "sandbox,usb-flash";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
usb_1: usb@1 {
|
|
|
|
compatible = "sandbox,usb";
|
2021-10-23 14:58:02 +00:00
|
|
|
iommus = <&iommu>;
|
2015-03-25 18:23:05 +00:00
|
|
|
hub {
|
|
|
|
compatible = "usb-hub";
|
|
|
|
usb,device-class = <9>;
|
2020-06-01 23:47:07 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2015-03-25 18:23:05 +00:00
|
|
|
hub-emul {
|
|
|
|
compatible = "sandbox,usb-hub";
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
2015-11-09 06:48:01 +00:00
|
|
|
flash-stick@0 {
|
2015-03-25 18:23:05 +00:00
|
|
|
reg = <0>;
|
|
|
|
compatible = "sandbox,usb-flash";
|
|
|
|
sandbox,filepath = "testflash.bin";
|
|
|
|
};
|
|
|
|
|
2015-11-09 06:48:01 +00:00
|
|
|
flash-stick@1 {
|
|
|
|
reg = <1>;
|
|
|
|
compatible = "sandbox,usb-flash";
|
|
|
|
sandbox,filepath = "testflash1.bin";
|
|
|
|
};
|
|
|
|
|
|
|
|
flash-stick@2 {
|
|
|
|
reg = <2>;
|
|
|
|
compatible = "sandbox,usb-flash";
|
|
|
|
sandbox,filepath = "testflash2.bin";
|
|
|
|
};
|
|
|
|
|
2015-11-09 06:48:08 +00:00
|
|
|
keyb@3 {
|
|
|
|
reg = <3>;
|
|
|
|
compatible = "sandbox,usb-keyb";
|
|
|
|
};
|
|
|
|
|
2015-03-25 18:23:05 +00:00
|
|
|
};
|
2020-06-01 23:47:07 +00:00
|
|
|
|
|
|
|
usbstor@1 {
|
|
|
|
reg = <1>;
|
|
|
|
};
|
|
|
|
usbstor@3 {
|
|
|
|
reg = <3>;
|
|
|
|
};
|
2015-03-25 18:23:05 +00:00
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
usb_2: usb@2 {
|
|
|
|
compatible = "sandbox,usb";
|
|
|
|
status = "disabled";
|
|
|
|
};
|
|
|
|
|
2016-03-31 21:12:28 +00:00
|
|
|
spmi: spmi@0 {
|
|
|
|
compatible = "sandbox,spmi";
|
|
|
|
#address-cells = <0x1>;
|
|
|
|
#size-cells = <0x1>;
|
2019-09-25 14:55:59 +00:00
|
|
|
ranges;
|
2016-03-31 21:12:28 +00:00
|
|
|
pm8916@0 {
|
|
|
|
compatible = "qcom,spmi-pmic";
|
|
|
|
reg = <0x0 0x1>;
|
|
|
|
#address-cells = <0x1>;
|
|
|
|
#size-cells = <0x1>;
|
2019-09-25 14:55:59 +00:00
|
|
|
ranges;
|
2016-03-31 21:12:28 +00:00
|
|
|
|
|
|
|
spmi_gpios: gpios@c000 {
|
|
|
|
compatible = "qcom,pm8916-gpio";
|
|
|
|
reg = <0xc000 0x400>;
|
|
|
|
gpio-controller;
|
|
|
|
gpio-count = <4>;
|
|
|
|
#gpio-cells = <2>;
|
|
|
|
gpio-bank-name="spmi";
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
2017-04-17 19:00:21 +00:00
|
|
|
|
|
|
|
wdt0: wdt@0 {
|
|
|
|
compatible = "sandbox,wdt";
|
2021-08-19 09:57:06 +00:00
|
|
|
hw_margin_ms = <200>;
|
2017-04-17 19:00:21 +00:00
|
|
|
};
|
2018-01-10 10:33:30 +00:00
|
|
|
|
2018-08-09 12:51:19 +00:00
|
|
|
axi: axi@0 {
|
|
|
|
compatible = "sandbox,axi";
|
|
|
|
#address-cells = <0x1>;
|
|
|
|
#size-cells = <0x1>;
|
|
|
|
store@0 {
|
|
|
|
compatible = "sandbox,sandbox_store";
|
|
|
|
reg = <0x0 0x400>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-01-10 10:33:30 +00:00
|
|
|
chosen {
|
2018-02-03 17:36:58 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <1>;
|
2020-01-27 15:49:43 +00:00
|
|
|
setting = "sunrise ohoka";
|
|
|
|
other-node = "/some-bus/c-test@5";
|
2020-01-27 15:49:46 +00:00
|
|
|
int-values = <0x1937 72993>;
|
2020-07-07 19:12:06 +00:00
|
|
|
u-boot,acpi-ssdt-order = <&acpi_test2 &acpi_test1>;
|
2018-01-10 10:33:30 +00:00
|
|
|
chosen-test {
|
|
|
|
compatible = "denx,u-boot-fdt-test";
|
|
|
|
reg = <9 1>;
|
|
|
|
};
|
|
|
|
};
|
2018-03-12 13:53:33 +00:00
|
|
|
|
|
|
|
translation-test@8000 {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
reg = <0x8000 0x4000>;
|
|
|
|
|
|
|
|
#address-cells = <0x2>;
|
|
|
|
#size-cells = <0x1>;
|
|
|
|
|
|
|
|
ranges = <0 0x0 0x8000 0x1000
|
|
|
|
1 0x100 0x9000 0x1000
|
|
|
|
2 0x200 0xA000 0x1000
|
|
|
|
3 0x300 0xB000 0x1000
|
|
|
|
>;
|
|
|
|
|
2019-05-31 13:11:30 +00:00
|
|
|
dma-ranges = <0 0x000 0x10000000 0x1000
|
|
|
|
1 0x100 0x20000000 0x1000
|
|
|
|
>;
|
|
|
|
|
2018-03-12 13:53:33 +00:00
|
|
|
dev@0,0 {
|
|
|
|
compatible = "denx,u-boot-fdt-dummy";
|
|
|
|
reg = <0 0x0 0x1000>;
|
2018-12-03 18:37:09 +00:00
|
|
|
reg-names = "sandbox-dummy-0";
|
2018-03-12 13:53:33 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
dev@1,100 {
|
|
|
|
compatible = "denx,u-boot-fdt-dummy";
|
|
|
|
reg = <1 0x100 0x1000>;
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
dev@2,200 {
|
|
|
|
compatible = "denx,u-boot-fdt-dummy";
|
|
|
|
reg = <2 0x200 0x1000>;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
noxlatebus@3,300 {
|
|
|
|
compatible = "simple-bus";
|
|
|
|
reg = <3 0x300 0x1000>;
|
|
|
|
|
|
|
|
#address-cells = <0x1>;
|
|
|
|
#size-cells = <0x0>;
|
|
|
|
|
|
|
|
dev@42 {
|
|
|
|
compatible = "denx,u-boot-fdt-dummy";
|
|
|
|
reg = <0x42>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
};
|
2018-09-27 07:19:31 +00:00
|
|
|
|
2023-01-22 15:21:23 +00:00
|
|
|
ofnode-foreach {
|
|
|
|
compatible = "foreach";
|
|
|
|
|
|
|
|
first {
|
|
|
|
prop1 = <1>;
|
|
|
|
prop2 = <2>;
|
|
|
|
};
|
|
|
|
|
|
|
|
second {
|
|
|
|
prop1 = <1>;
|
|
|
|
prop2 = <2>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-09-27 07:19:31 +00:00
|
|
|
osd {
|
|
|
|
compatible = "sandbox,sandbox_osd";
|
|
|
|
};
|
2018-09-30 22:16:51 +00:00
|
|
|
|
2018-09-25 14:40:16 +00:00
|
|
|
sandbox_tee {
|
|
|
|
compatible = "sandbox,tee";
|
|
|
|
};
|
2018-10-15 09:21:26 +00:00
|
|
|
|
|
|
|
sandbox_virtio1 {
|
|
|
|
compatible = "sandbox,virtio1";
|
2023-01-17 17:47:51 +00:00
|
|
|
virtio-type = <4>; /* rng */
|
2018-10-15 09:21:26 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
sandbox_virtio2 {
|
|
|
|
compatible = "sandbox,virtio2";
|
|
|
|
};
|
2018-10-24 12:10:23 +00:00
|
|
|
|
2023-01-17 17:47:51 +00:00
|
|
|
sandbox-virtio-blk {
|
|
|
|
compatible = "sandbox,virtio1";
|
|
|
|
virtio-type = <2>; /* block */
|
|
|
|
};
|
|
|
|
|
2020-09-09 16:44:05 +00:00
|
|
|
sandbox_scmi {
|
|
|
|
compatible = "sandbox,scmi-devices";
|
2022-02-21 08:22:41 +00:00
|
|
|
clocks = <&clk_scmi 2>, <&clk_scmi 0>;
|
2022-02-21 08:22:39 +00:00
|
|
|
resets = <&reset_scmi 3>;
|
|
|
|
regul0-supply = <®ul0_scmi>;
|
|
|
|
regul1-supply = <®ul1_scmi>;
|
2020-09-09 16:44:05 +00:00
|
|
|
};
|
|
|
|
|
2018-10-24 12:10:23 +00:00
|
|
|
pinctrl {
|
|
|
|
compatible = "sandbox,pinctrl";
|
2020-01-13 10:35:12 +00:00
|
|
|
|
2020-09-14 15:01:57 +00:00
|
|
|
pinctrl-names = "default", "alternate";
|
|
|
|
pinctrl-0 = <&pinctrl_gpios>, <&pinctrl_i2s>;
|
|
|
|
pinctrl-1 = <&pinctrl_spi>, <&pinctrl_i2c>;
|
2020-01-13 10:35:12 +00:00
|
|
|
|
2020-09-14 15:01:57 +00:00
|
|
|
pinctrl_gpios: gpios {
|
2020-01-13 10:35:12 +00:00
|
|
|
gpio0 {
|
2020-09-14 15:01:57 +00:00
|
|
|
pins = "P5";
|
|
|
|
function = "GPIO";
|
2020-01-13 10:35:12 +00:00
|
|
|
bias-pull-up;
|
|
|
|
input-disable;
|
|
|
|
};
|
|
|
|
gpio1 {
|
2020-09-14 15:01:57 +00:00
|
|
|
pins = "P6";
|
|
|
|
function = "GPIO";
|
2020-01-13 10:35:12 +00:00
|
|
|
output-high;
|
|
|
|
drive-open-drain;
|
|
|
|
};
|
|
|
|
gpio2 {
|
2020-09-14 15:01:57 +00:00
|
|
|
pinmux = <SANDBOX_PINMUX(7, SANDBOX_PINMUX_GPIO)>;
|
2020-01-13 10:35:12 +00:00
|
|
|
bias-pull-down;
|
|
|
|
input-enable;
|
|
|
|
};
|
|
|
|
gpio3 {
|
2020-09-14 15:01:57 +00:00
|
|
|
pinmux = <SANDBOX_PINMUX(8, SANDBOX_PINMUX_GPIO)>;
|
2020-01-13 10:35:12 +00:00
|
|
|
bias-disable;
|
|
|
|
};
|
|
|
|
};
|
2020-09-14 15:01:57 +00:00
|
|
|
|
|
|
|
pinctrl_i2c: i2c {
|
|
|
|
groups {
|
|
|
|
groups = "I2C_UART";
|
|
|
|
function = "I2C";
|
|
|
|
};
|
|
|
|
|
|
|
|
pins {
|
|
|
|
pins = "P0", "P1";
|
|
|
|
drive-open-drain;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
pinctrl_i2s: i2s {
|
|
|
|
groups = "SPI_I2S";
|
|
|
|
function = "I2S";
|
|
|
|
};
|
|
|
|
|
|
|
|
pinctrl_spi: spi {
|
|
|
|
groups = "SPI_I2S";
|
|
|
|
function = "SPI";
|
|
|
|
|
|
|
|
cs {
|
|
|
|
pinmux = <SANDBOX_PINMUX(5, SANDBOX_PINMUX_CS)>,
|
|
|
|
<SANDBOX_PINMUX(6, SANDBOX_PINMUX_CS)>;
|
|
|
|
};
|
|
|
|
};
|
2018-10-24 12:10:23 +00:00
|
|
|
};
|
2018-11-27 12:49:50 +00:00
|
|
|
|
2021-04-11 07:39:50 +00:00
|
|
|
pinctrl-single-no-width {
|
|
|
|
compatible = "pinctrl-single";
|
|
|
|
reg = <0x0000 0x238>;
|
|
|
|
#pinctrl-cells = <1>;
|
|
|
|
pinctrl-single,function-mask = <0x7f>;
|
|
|
|
};
|
|
|
|
|
|
|
|
pinctrl-single-pins {
|
|
|
|
compatible = "pinctrl-single";
|
|
|
|
reg = <0x0000 0x238>;
|
|
|
|
#pinctrl-cells = <1>;
|
|
|
|
pinctrl-single,register-width = <32>;
|
|
|
|
pinctrl-single,function-mask = <0x7f>;
|
|
|
|
|
|
|
|
pinmux_pwm_pins: pinmux_pwm_pins {
|
|
|
|
pinctrl-single,pins = < 0x48 0x06 >;
|
|
|
|
};
|
|
|
|
|
|
|
|
pinmux_spi0_pins: pinmux_spi0_pins {
|
|
|
|
pinctrl-single,pins = <
|
|
|
|
0x190 0x0c
|
|
|
|
0x194 0x0c
|
|
|
|
0x198 0x23
|
|
|
|
0x19c 0x0c
|
|
|
|
>;
|
|
|
|
};
|
|
|
|
|
|
|
|
pinmux_uart0_pins: pinmux_uart0_pins {
|
|
|
|
pinctrl-single,pins = <
|
|
|
|
0x70 0x30
|
|
|
|
0x74 0x00
|
|
|
|
>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
pinctrl-single-bits {
|
|
|
|
compatible = "pinctrl-single";
|
|
|
|
reg = <0x0000 0x50>;
|
|
|
|
#pinctrl-cells = <2>;
|
|
|
|
pinctrl-single,bit-per-mux;
|
|
|
|
pinctrl-single,register-width = <32>;
|
|
|
|
pinctrl-single,function-mask = <0xf>;
|
|
|
|
|
|
|
|
pinmux_i2c0_pins: pinmux_i2c0_pins {
|
|
|
|
pinctrl-single,bits = <
|
|
|
|
0x10 0x00002200 0x0000ff00
|
|
|
|
>;
|
|
|
|
};
|
|
|
|
|
|
|
|
pinmux_lcd_pins: pinmux_lcd_pins {
|
|
|
|
pinctrl-single,bits = <
|
|
|
|
0x40 0x22222200 0xffffff00
|
|
|
|
0x44 0x22222222 0xffffffff
|
|
|
|
0x48 0x00000022 0x000000ff
|
|
|
|
0x48 0x02000000 0x0f000000
|
|
|
|
0x4c 0x02000022 0x0f0000ff
|
|
|
|
>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2018-11-27 12:49:50 +00:00
|
|
|
hwspinlock@0 {
|
|
|
|
compatible = "sandbox,hwspinlock";
|
|
|
|
};
|
2018-11-28 18:17:51 +00:00
|
|
|
|
|
|
|
dma: dma {
|
|
|
|
compatible = "sandbox,dma";
|
|
|
|
#dma-cells = <1>;
|
|
|
|
|
|
|
|
dmas = <&dma 0>, <&dma 1>, <&dma 2>;
|
|
|
|
dma-names = "m2m", "tx0", "rx0";
|
|
|
|
};
|
2019-06-03 16:12:28 +00:00
|
|
|
|
2019-07-12 07:13:53 +00:00
|
|
|
/*
|
|
|
|
* keep mdio-mux ahead of mdio so that the mux is removed first at the
|
|
|
|
* end of the test. If parent mdio is removed first, clean-up of the
|
|
|
|
* mux will trigger a 2nd probe of parent-mdio, leaving parent-mdio
|
|
|
|
* active at the end of the test. That it turn doesn't allow the mdio
|
|
|
|
* class to be destroyed, triggering an error.
|
|
|
|
*/
|
|
|
|
mdio-mux-test {
|
|
|
|
compatible = "sandbox,mdio-mux";
|
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
|
|
|
mdio-parent-bus = <&mdio>;
|
|
|
|
|
|
|
|
mdio-ch-test@0 {
|
|
|
|
reg = <0>;
|
|
|
|
};
|
|
|
|
mdio-ch-test@1 {
|
|
|
|
reg = <1>;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
|
|
|
mdio: mdio-test {
|
2019-06-03 16:12:28 +00:00
|
|
|
compatible = "sandbox,mdio";
|
2022-04-06 22:32:57 +00:00
|
|
|
#address-cells = <1>;
|
|
|
|
#size-cells = <0>;
|
|
|
|
|
|
|
|
ethphy1: ethernet-phy@1 {
|
|
|
|
reg = <1>;
|
|
|
|
};
|
2019-06-03 16:12:28 +00:00
|
|
|
};
|
2020-06-24 10:41:12 +00:00
|
|
|
|
|
|
|
pm-bus-test {
|
|
|
|
compatible = "simple-pm-bus";
|
|
|
|
clocks = <&clk_sandbox 4>;
|
|
|
|
power-domains = <&pwrdom 1>;
|
|
|
|
};
|
2020-06-24 10:41:14 +00:00
|
|
|
|
|
|
|
resetc2: syscon-reset {
|
|
|
|
compatible = "syscon-reset";
|
|
|
|
#reset-cells = <1>;
|
|
|
|
regmap = <&syscon0>;
|
|
|
|
offset = <1>;
|
|
|
|
mask = <0x27FFFFFF>;
|
|
|
|
assert-high = <0>;
|
|
|
|
};
|
|
|
|
|
|
|
|
syscon-reset-test {
|
|
|
|
compatible = "sandbox,misc_sandbox";
|
|
|
|
resets = <&resetc2 15>, <&resetc2 30>, <&resetc2 60>;
|
|
|
|
reset-names = "valid", "no_mask", "out_of_range";
|
|
|
|
};
|
2020-09-24 04:34:18 +00:00
|
|
|
|
2020-11-05 13:32:05 +00:00
|
|
|
sysinfo {
|
|
|
|
compatible = "sandbox,sysinfo-sandbox";
|
|
|
|
};
|
|
|
|
|
2021-04-20 14:50:58 +00:00
|
|
|
sysinfo-gpio {
|
|
|
|
compatible = "gpio-sysinfo";
|
|
|
|
gpios = <&gpio_a 15>, <&gpio_a 16>, <&gpio_a 17>;
|
|
|
|
revisions = <19>, <5>;
|
|
|
|
names = "rev_a", "foo";
|
|
|
|
};
|
|
|
|
|
2020-09-24 04:34:18 +00:00
|
|
|
some_regmapped-bus {
|
|
|
|
#address-cells = <0x1>;
|
|
|
|
#size-cells = <0x1>;
|
|
|
|
|
|
|
|
ranges = <0x0 0x0 0x10>;
|
|
|
|
compatible = "simple-bus";
|
|
|
|
|
|
|
|
regmap-test_0 {
|
|
|
|
reg = <0 0x10>;
|
|
|
|
compatible = "sandbox,regmap_test";
|
|
|
|
};
|
|
|
|
};
|
2022-09-06 11:30:35 +00:00
|
|
|
|
|
|
|
thermal {
|
|
|
|
compatible = "sandbox,thermal";
|
|
|
|
};
|
2022-10-21 12:46:05 +00:00
|
|
|
|
|
|
|
fwu-mdata {
|
|
|
|
compatible = "u-boot,fwu-mdata-gpt";
|
|
|
|
fwu-mdata-store = <&mmc0>;
|
|
|
|
};
|
2023-04-17 09:11:55 +00:00
|
|
|
|
|
|
|
nvmxip-qspi1@08000000 {
|
|
|
|
compatible = "nvmxip,qspi";
|
|
|
|
reg = <0x08000000 0x00200000>;
|
|
|
|
lba_shift = <9>;
|
|
|
|
lba = <4096>;
|
|
|
|
};
|
|
|
|
|
|
|
|
nvmxip-qspi2@08200000 {
|
|
|
|
compatible = "nvmxip,qspi";
|
|
|
|
reg = <0x08200000 0x00100000>;
|
|
|
|
lba_shift = <9>;
|
|
|
|
lba = <2048>;
|
|
|
|
};
|
2023-04-25 07:57:21 +00:00
|
|
|
|
|
|
|
extcon {
|
|
|
|
compatible = "sandbox,extcon";
|
|
|
|
};
|
2023-08-04 13:33:41 +00:00
|
|
|
|
|
|
|
arm-ffa-emul {
|
|
|
|
compatible = "sandbox,arm-ffa-emul";
|
|
|
|
|
|
|
|
sandbox-arm-ffa {
|
|
|
|
compatible = "sandbox,arm-ffa";
|
|
|
|
};
|
|
|
|
};
|
2014-02-26 22:59:21 +00:00
|
|
|
};
|
2015-05-13 11:38:35 +00:00
|
|
|
|
|
|
|
#include "sandbox_pmic.dtsi"
|
2021-02-18 12:01:35 +00:00
|
|
|
#include "cros-ec-keyboard.dtsi"
|
2022-10-21 00:23:15 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_SANDBOX_VPL
|
|
|
|
#include "sandbox_vpl.dtsi"
|
|
|
|
#endif
|
2023-06-01 16:23:01 +00:00
|
|
|
|
|
|
|
#include "cedit.dtsi"
|