/dts-v1/; 
 | 
  
 | 
/ { 
 | 
    model = "sandbox"; 
 | 
    compatible = "sandbox"; 
 | 
    #address-cells = <1>; 
 | 
    #size-cells = <1>; 
 | 
  
 | 
    aliases { 
 | 
        console = &uart0; 
 | 
        eth0 = "/eth@10002000"; 
 | 
        eth3 = ð_3; 
 | 
        eth5 = ð_5; 
 | 
        i2c0 = "/i2c@0"; 
 | 
        mmc0 = "/mmc0"; 
 | 
        mmc1 = "/mmc1"; 
 | 
        pci0 = &pci; 
 | 
        remoteproc1 = &rproc_1; 
 | 
        remoteproc2 = &rproc_2; 
 | 
        rtc0 = &rtc_0; 
 | 
        rtc1 = &rtc_1; 
 | 
        spi0 = "/spi@0"; 
 | 
        testfdt6 = "/e-test"; 
 | 
        testbus3 = "/some-bus"; 
 | 
        testfdt0 = "/some-bus/c-test@0"; 
 | 
        testfdt1 = "/some-bus/c-test@1"; 
 | 
        testfdt3 = "/b-test"; 
 | 
        testfdt5 = "/some-bus/c-test@5"; 
 | 
        testfdt8 = "/a-test"; 
 | 
        usb0 = &usb_0; 
 | 
        usb1 = &usb_1; 
 | 
        usb2 = &usb_2; 
 | 
    }; 
 | 
  
 | 
    a-test { 
 | 
        reg = <0 1>; 
 | 
        compatible = "denx,u-boot-fdt-test"; 
 | 
        ping-expect = <0>; 
 | 
        ping-add = <0>; 
 | 
        u-boot,dm-pre-reloc; 
 | 
        test-gpios = <&gpio_a 1>, <&gpio_a 4>, <&gpio_b 5 0 3 2 1>, 
 | 
            <0>, <&gpio_a 12>; 
 | 
        test2-gpios = <&gpio_a 1>, <&gpio_a 4>, <&gpio_b 6 1 3 2 1>, 
 | 
            <&gpio_b 7 2 3 2 1>, <&gpio_b 8 4 3 2 1>, 
 | 
            <&gpio_b 9 0xc 3 2 1>; 
 | 
    }; 
 | 
  
 | 
    junk { 
 | 
        reg = <1 1>; 
 | 
        compatible = "not,compatible"; 
 | 
    }; 
 | 
  
 | 
    no-compatible { 
 | 
        reg = <2 1>; 
 | 
    }; 
 | 
  
 | 
    b-test { 
 | 
        reg = <3 1>; 
 | 
        compatible = "denx,u-boot-fdt-test"; 
 | 
        ping-expect = <3>; 
 | 
        ping-add = <3>; 
 | 
    }; 
 | 
  
 | 
    phy_provider0: gen_phy@0 { 
 | 
        compatible = "sandbox,phy"; 
 | 
        #phy-cells = <1>; 
 | 
    }; 
 | 
  
 | 
    phy_provider1: gen_phy@1 { 
 | 
        compatible = "sandbox,phy"; 
 | 
        #phy-cells = <0>; 
 | 
        broken; 
 | 
    }; 
 | 
  
 | 
    gen_phy_user: gen_phy_user { 
 | 
        compatible = "simple-bus"; 
 | 
        phys = <&phy_provider0 0>, <&phy_provider0 1>, <&phy_provider1>; 
 | 
        phy-names = "phy1", "phy2", "phy3"; 
 | 
    }; 
 | 
  
 | 
    some-bus { 
 | 
        #address-cells = <1>; 
 | 
        #size-cells = <0>; 
 | 
        compatible = "denx,u-boot-test-bus"; 
 | 
        reg = <3 1>; 
 | 
        ping-expect = <4>; 
 | 
        ping-add = <4>; 
 | 
        c-test@5 { 
 | 
            compatible = "denx,u-boot-fdt-test"; 
 | 
            reg = <5>; 
 | 
            ping-expect = <5>; 
 | 
            ping-add = <5>; 
 | 
        }; 
 | 
        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>; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    d-test { 
 | 
        reg = <3 1>; 
 | 
        ping-expect = <6>; 
 | 
        ping-add = <6>; 
 | 
        compatible = "google,another-fdt-test"; 
 | 
    }; 
 | 
  
 | 
    e-test { 
 | 
        reg = <3 1>; 
 | 
        ping-expect = <6>; 
 | 
        ping-add = <6>; 
 | 
        compatible = "google,another-fdt-test"; 
 | 
    }; 
 | 
  
 | 
    f-test { 
 | 
        compatible = "denx,u-boot-fdt-test"; 
 | 
    }; 
 | 
  
 | 
    g-test { 
 | 
        compatible = "denx,u-boot-fdt-test"; 
 | 
    }; 
 | 
  
 | 
    clocks { 
 | 
        clk_fixed: clk-fixed { 
 | 
            compatible = "fixed-clock"; 
 | 
            #clock-cells = <0>; 
 | 
            clock-frequency = <1234>; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    clk_sandbox: clk-sbox { 
 | 
        compatible = "sandbox,clk"; 
 | 
        #clock-cells = <1>; 
 | 
    }; 
 | 
  
 | 
    clk-test { 
 | 
        compatible = "sandbox,clk-test"; 
 | 
        clocks = <&clk_fixed>, 
 | 
             <&clk_sandbox 1>, 
 | 
             <&clk_sandbox 0>; 
 | 
        clock-names = "fixed", "i2c", "spi"; 
 | 
    }; 
 | 
  
 | 
    eth@10002000 { 
 | 
        compatible = "sandbox,eth"; 
 | 
        reg = <0x10002000 0x1000>; 
 | 
        fake-host-hwaddr = <0x00 0x00 0x66 0x44 0x22 0x00>; 
 | 
    }; 
 | 
  
 | 
    eth_5: eth@10003000 { 
 | 
        compatible = "sandbox,eth"; 
 | 
        reg = <0x10003000 0x1000>; 
 | 
        fake-host-hwaddr = <0x00 0x00 0x66 0x44 0x22 0x11>; 
 | 
    }; 
 | 
  
 | 
    eth_3: sbe5 { 
 | 
        compatible = "sandbox,eth"; 
 | 
        reg = <0x10005000 0x1000>; 
 | 
        fake-host-hwaddr = <0x00 0x00 0x66 0x44 0x22 0x33>; 
 | 
    }; 
 | 
  
 | 
    eth@10004000 { 
 | 
        compatible = "sandbox,eth"; 
 | 
        reg = <0x10004000 0x1000>; 
 | 
        fake-host-hwaddr = <0x00 0x00 0x66 0x44 0x22 0x22>; 
 | 
    }; 
 | 
  
 | 
    firmware { 
 | 
        sandbox_firmware: sandbox-firmware { 
 | 
            compatible = "sandbox,firmware"; 
 | 
        }; 
 | 
  
 | 
        sandbox-scmi-agent@0 { 
 | 
            compatible = "sandbox,scmi-agent"; 
 | 
            #address-cells = <1>; 
 | 
            #size-cells = <0>; 
 | 
        }; 
 | 
  
 | 
        sandbox-scmi-agent@1 { 
 | 
            compatible = "sandbox,scmi-agent"; 
 | 
            #address-cells = <1>; 
 | 
            #size-cells = <0>; 
 | 
  
 | 
            protocol@10 { 
 | 
                reg = <0x10>; 
 | 
            }; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    gpio_a: base-gpios { 
 | 
        compatible = "sandbox,gpio"; 
 | 
        gpio-controller; 
 | 
        #gpio-cells = <1>; 
 | 
        gpio-bank-name = "a"; 
 | 
        num-gpios = <20>; 
 | 
    }; 
 | 
  
 | 
    gpio_b: extra-gpios { 
 | 
        compatible = "sandbox,gpio"; 
 | 
        gpio-controller; 
 | 
        #gpio-cells = <5>; 
 | 
        gpio-bank-name = "b"; 
 | 
        num-gpios = <10>; 
 | 
    }; 
 | 
  
 | 
    i2c@0 { 
 | 
        #address-cells = <1>; 
 | 
        #size-cells = <0>; 
 | 
        reg = <0 1>; 
 | 
        compatible = "sandbox,i2c"; 
 | 
        clock-frequency = <100000>; 
 | 
        eeprom@2c { 
 | 
            reg = <0x2c>; 
 | 
            compatible = "i2c-eeprom"; 
 | 
            emul { 
 | 
                compatible = "sandbox,i2c-eeprom"; 
 | 
                sandbox,filename = "i2c.bin"; 
 | 
                sandbox,size = <256>; 
 | 
            }; 
 | 
        }; 
 | 
  
 | 
        rtc_0: rtc@43 { 
 | 
            reg = <0x43>; 
 | 
            compatible = "sandbox-rtc"; 
 | 
            emul { 
 | 
                compatible = "sandbox,i2c-rtc"; 
 | 
            }; 
 | 
        }; 
 | 
  
 | 
        rtc_1: rtc@61 { 
 | 
            reg = <0x61>; 
 | 
            compatible = "sandbox-rtc"; 
 | 
            emul { 
 | 
                compatible = "sandbox,i2c-rtc"; 
 | 
            }; 
 | 
        }; 
 | 
  
 | 
        sandbox_pmic: sandbox_pmic { 
 | 
            reg = <0x40>; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    adc@0 { 
 | 
        compatible = "sandbox,adc"; 
 | 
        vdd-supply = <&buck2>; 
 | 
        vss-microvolts = <0>; 
 | 
    }; 
 | 
  
 | 
    lcd { 
 | 
        u-boot,dm-pre-reloc; 
 | 
        compatible = "sandbox,lcd-sdl"; 
 | 
        xres = <1366>; 
 | 
        yres = <768>; 
 | 
    }; 
 | 
  
 | 
    leds { 
 | 
        compatible = "gpio-leds"; 
 | 
  
 | 
        iracibble { 
 | 
            gpios = <&gpio_a 1 0>; 
 | 
            label = "sandbox:red"; 
 | 
        }; 
 | 
  
 | 
        martinet { 
 | 
            gpios = <&gpio_a 2 0>; 
 | 
            label = "sandbox:green"; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    mbox: mbox { 
 | 
        compatible = "sandbox,mbox"; 
 | 
        #mbox-cells = <1>; 
 | 
    }; 
 | 
  
 | 
    mbox-test { 
 | 
        compatible = "sandbox,mbox-test"; 
 | 
        mboxes = <&mbox 100>, <&mbox 1>; 
 | 
        mbox-names = "other", "test"; 
 | 
    }; 
 | 
  
 | 
    mmc2 { 
 | 
        compatible = "sandbox,mmc"; 
 | 
    }; 
 | 
  
 | 
    mmc1 { 
 | 
        compatible = "sandbox,mmc"; 
 | 
    }; 
 | 
  
 | 
    mmc0 { 
 | 
        compatible = "sandbox,mmc"; 
 | 
    }; 
 | 
  
 | 
    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"; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    pci: pci-controller { 
 | 
        compatible = "sandbox,pci"; 
 | 
        device_type = "pci"; 
 | 
        #address-cells = <3>; 
 | 
        #size-cells = <2>; 
 | 
        ranges = <0x02000000 0 0x10000000 0x10000000 0 0x2000 
 | 
                0x01000000 0 0x20000000 0x20000000 0 0x2000>; 
 | 
        pci@1f,0 { 
 | 
            compatible = "pci-generic"; 
 | 
            reg = <0xf800 0 0 0 0>; 
 | 
            emul@1f,0 { 
 | 
                compatible = "sandbox,swap-case"; 
 | 
            }; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    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"; 
 | 
            first-syscon = <&syscon0>; 
 | 
            second-sys-ctrl = <&another_system_controller>; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    pwrdom: power-domain { 
 | 
        compatible = "sandbox,power-domain"; 
 | 
        #power-domain-cells = <1>; 
 | 
    }; 
 | 
  
 | 
    power-domain-test { 
 | 
        compatible = "sandbox,power-domain-test"; 
 | 
        power-domains = <&pwrdom 2>; 
 | 
    }; 
 | 
  
 | 
    pwm { 
 | 
        compatible = "sandbox,pwm"; 
 | 
    }; 
 | 
  
 | 
    pwm2 { 
 | 
        compatible = "sandbox,pwm"; 
 | 
    }; 
 | 
  
 | 
    ram { 
 | 
        compatible = "sandbox,ram"; 
 | 
    }; 
 | 
  
 | 
    reset@0 { 
 | 
        compatible = "sandbox,warm-reset"; 
 | 
    }; 
 | 
  
 | 
    reset@1 { 
 | 
        compatible = "sandbox,reset"; 
 | 
    }; 
 | 
  
 | 
    resetc: reset-ctl { 
 | 
        compatible = "sandbox,reset-ctl"; 
 | 
        #reset-cells = <1>; 
 | 
    }; 
 | 
  
 | 
    reset-ctl-test { 
 | 
        compatible = "sandbox,reset-ctl-test"; 
 | 
        resets = <&resetc 100>, <&resetc 2>; 
 | 
        reset-names = "other", "test"; 
 | 
    }; 
 | 
  
 | 
    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"; 
 | 
    }; 
 | 
  
 | 
    spi@0 { 
 | 
        #address-cells = <1>; 
 | 
        #size-cells = <0>; 
 | 
        reg = <0 1>; 
 | 
        compatible = "sandbox,spi"; 
 | 
        cs-gpios = <0>, <&gpio_a 0>; 
 | 
        spi.bin@0 { 
 | 
            reg = <0>; 
 | 
            compatible = "spansion,m25p16", "spi-flash"; 
 | 
            spi-max-frequency = <40000000>; 
 | 
            sandbox,filename = "spi.bin"; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    syscon0: syscon@0 { 
 | 
        compatible = "sandbox,syscon0"; 
 | 
        reg = <0x10 4>; 
 | 
    }; 
 | 
  
 | 
    another_system_controller: syscon@1 { 
 | 
        compatible = "sandbox,syscon1"; 
 | 
        reg = <0x20 5 
 | 
            0x28 6 
 | 
            0x30 7 
 | 
            0x38 8>; 
 | 
    }; 
 | 
  
 | 
    timer { 
 | 
        compatible = "sandbox,timer"; 
 | 
        clock-frequency = <1000000>; 
 | 
    }; 
 | 
  
 | 
    uart0: serial { 
 | 
        compatible = "sandbox,serial"; 
 | 
        u-boot,dm-pre-reloc; 
 | 
    }; 
 | 
  
 | 
    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"; 
 | 
        hub { 
 | 
            compatible = "usb-hub"; 
 | 
            usb,device-class = <9>; 
 | 
            hub-emul { 
 | 
                compatible = "sandbox,usb-hub"; 
 | 
                #address-cells = <1>; 
 | 
                #size-cells = <0>; 
 | 
                flash-stick@0 { 
 | 
                    reg = <0>; 
 | 
                    compatible = "sandbox,usb-flash"; 
 | 
                    sandbox,filepath = "testflash.bin"; 
 | 
                }; 
 | 
  
 | 
                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"; 
 | 
                }; 
 | 
  
 | 
                keyb@3 { 
 | 
                    reg = <3>; 
 | 
                    compatible = "sandbox,usb-keyb"; 
 | 
                }; 
 | 
  
 | 
            }; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    usb_2: usb@2 { 
 | 
        compatible = "sandbox,usb"; 
 | 
        status = "disabled"; 
 | 
    }; 
 | 
  
 | 
    spmi: spmi@0 { 
 | 
        compatible = "sandbox,spmi"; 
 | 
        #address-cells = <0x1>; 
 | 
        #size-cells = <0x1>; 
 | 
        pm8916@0 { 
 | 
            compatible = "qcom,spmi-pmic"; 
 | 
            reg = <0x0 0x1>; 
 | 
            #address-cells = <0x1>; 
 | 
            #size-cells = <0x1>; 
 | 
  
 | 
            spmi_gpios: gpios@c000 { 
 | 
                compatible = "qcom,pm8916-gpio"; 
 | 
                reg = <0xc000 0x400>; 
 | 
                gpio-controller; 
 | 
                gpio-count = <4>; 
 | 
                #gpio-cells = <2>; 
 | 
                gpio-bank-name="spmi"; 
 | 
            }; 
 | 
        }; 
 | 
    }; 
 | 
  
 | 
    wdt0: wdt@0 { 
 | 
        compatible = "sandbox,wdt"; 
 | 
    }; 
 | 
}; 
 | 
  
 | 
#include "sandbox_pmic.dtsi" 
 |