Devicetree is a paired down version of OF; they retained the tree containing key/value device metadata, and dropped all the good bits.
Open source doesn’t mean not shipping binaries.
UEFI still has this doesn't it? EFI byte code [0].
[0] - https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-gui...
Something like the missing Forth interpreter would be invaluable on development boards as well as for diagnostics on embedded devices. Or simply for fun. I used to spend hours exploring PowerMacs and Forth programming, all thanks to OpenFirmware.
From firsthand experience, I can say that at least installing Linux on a UEFI ARM system of the type that QEMU emulates was surprisingly straightforward, and even the ARM version of Windows seemed to detect the virtual hardware just fine.
...and I say this as someone who has worked on the PC platform for over 3 decades, and am a fan of the original BIOS. UEFI is a bloated mess, but it's better than nothing.
But a lot of ARM hardware is that type. The keywords are SBSA / SBBR / SystemReady. If your hardware is SBBR compatible then Fedora and Ubuntu's ARM64 iso, and Windows ARM64, downloaded from their website, will at least boot fine (drivers are a different question as always).
There's a good list of supported hardware in the lower half of https://community.arm.com/arm-community-blogs/b/architecture... . Many systems from Avantek, Gigabyte, NXP, Marvell, Solidrun etc are standardizing on this way of booting.
DeviceTree is low-level enough that you can implement UEFI on top of it. There's a UEFI port for the Raspberry Pi 4 at https://rpi4-uefi.dev/ that produces an SBBR layer, allowing it to boot any off-the-shelf ARM64 SBBR distro.
That "describes itself to the OS" part is actually often being done by a complete OS as well.
> Unfortunately, UEFI/ACPI or simliar seems to be going nowhere in the ARM world, so it doesn't seem installing Windows/Linux is going to be as easy on ARM as on x86 anytime soon.
That's a really good thing. Bryan rants about ARM trying to go that way and thinks it's a terrible idea. I'm glad it's failing, assuming that's actually the case.
I'd be curious why because the PC model seems to be way more user-friendly, competition-friendly, and long-term-reliable than the current ARM model. I wish I could just download an ISO of Android 13 and install it on almost any Android phone like I could Windows.
Open Firmware—between the device tree system and the bytecode driver system—plus ELF provide a truly universal boot protocol for 32-bit and larger systems. And not only that, major and tractable implementations are now Open Source too, including things like the bytecode compilers.
It’s practically unconscionable that modern ARM and RISC-V don’t simply require Open Firmware boot support.
All the pieces are in place for RISC-V to effectively dodge boot chaos. Way before the server/workstation RISC-V hardware hit the market.
In ARM, it's a mess. Because ARM took way too long to do way too little re: boot standardization.
Imagine scaling that up to GPUs! The device needs to describe itself because IT is unique.
I encourage you to spend more time with it. Meet your hero. Get to know it. Understanding will surely follow. 8)
Having worked with ARM too I have to disagree. I found device trees really flexible and easy to get going.
However, I worked with Rockchip hardware so I had pretty good documentation, lots of examples, and source code for everything(for an old linux kernel, but still). This basically ensured I could do everything I wanted.
Of course, when a vendor doesn't provide documentation and example driver source this may not be so easy.
... as opposed to not having to "get it going at all"?
Everything I have came from 3 sources. There is a Linux BSP SDK file (36GB or so) and an Android SDK (75gb or so). Both have docs folders with lots of docs documenting various sdks (for the gpu, npu, camera etc). Those files also contain drivers source for old linux kernels that can be adapted to newer ones with a bit of work. Both are linked on pine's wiki under soquartz. Just Google soquartz pine wiki.
The third resource is just two parts of rk3568 TRM(same as rk3566) . They are here: https://github.com/heitbaum/rk3568/tree/main/doc
But even with Rockchip, different vendors have different levels of support. We had one potential vendor that had excellent documentation, delivered the source code to everything, and responded really quickly and helpfully - in english - to questions. But they were way to expensive. And we had another who just gave us some mystery Android + Linux images, GPL violation included. No schematics. I spent some time porting Linux from one board to the other - they were very similar - but never finished, and constantly was afraid of configuring a voltage regulator wrong and blowing it up, or something similar.
Compare to x86 where I can just order random parts form newegg, screw them together and pop in a boot USB drive, and it will mostly work. I know that you get what you pay for, but at least I would expect the SBC vendors to do hardware enablement, and provide some kind of abstraction that I can run my OS on (or upstream their code).
With EDK2, on x86?
Or configure and tuning some custom DDR that happen to be already soldered on the board? Or bootstraping some parameters from an EEPROM or external microcontroller?
Compiling and customizing EDK2 for x86 (to boot Windows) was a nightmare and I never want to do it again. I'd rather "make aboot -j8" my entire life.
Please tell me you've found the secret formula to automagically add ANY display panel purchased somewhere in Asia, on x86. Otherwise I'll back to praise the devicetree.
But that's exactly the point of device trees. You should be able to use generic ARM kernel build, and it loads appropriate drivers based on dtb provided by system firmware.
ACPI on x86 works the same way - it's in ROM but the OS doesn't necessarily use it blindly, it has plenty of quirks to interpret it with.
Even then, it would be even better if that library were open source that the OS could carry its own artifacts of. Not because open source is great, but so the OS can truly be in control. The point u/bcantrill makes about the OS not getting DRAM error information gives me cold sweats!
If the library is open source, then, yes, each boot loader and kernel will have to be built for the hardware it will boot on, at least until it gets far enough to get additional firmware/drivers from a boot image RAM disk or whatever.
This is not "the x86 model". This is the "Microsoft refuses to support anything" model.
It is dead, and good f*ing riddance.
It's rather "Everyone wants to boot Windows, and Microsoft can't be bothered to deal with everyone" model.
https://github.com/AsahiLinux/docs/wiki/Introduction-to-Appl...
What do you mean by that? Every ARM server has UEFI/ACPI, and it's now looking like every new PC using ARM will include it out of the box. There are even UEFI images for Raspberry Pi 4. Sure, the embedded space is probably going to be holding out for a while longer, but seems disingenuous to say UEFI is going nowhere in the ARM world.
You should be able to put vanilla Ubuntu on a SD card and pop it into a computer and get at least the basic features working. Instead, now you have the choice between opaque firmware images from the vendor (with an ancient kernel, and random additions to userspace), or building your own images with a lot of tinkering.
There is now a generic BSA https://developer.arm.com/documentation/den0094/latest (not server specific)
The major difference on X86 is that it is (for historical reasons) much more standardised at the hardware level than on ARM (at least on embedded ARM, there is more standardisation in the ARM server space). It also makes more use of discoverable busses like USB and PCI so the parts that need to be described in ACPI are smaller than the parts that have to be described in DT on ARM (as much is either "implicitly standardised" or on a discoverable bus).
And that is because all PCs are basically the same whereas there is a huge variety in ARM SoC hardware and boards, mostly for understandable reasons (there are a huge variety of use cases and price points in embedded systems).
If you were to build an embedded X86 system not using a PC architecture (North bridge, South bridege etc) but using the processor and your own design you would have exactly the same problem.
That said you don't have to have "hardcoded firmware images for every single device" in the embedded ARM world.
I build an in house BSP for a product family of ~15 devices based on 3 different SoCs and we have a single kernel and userspace (Debian based) for all of them. All the DTs are on the boot partition and the bootloader selects the right one based on hardware information (typically a small EEPROM).
The only part that has to be different is the bootloader itself (and then not different for every device but for each SoC) - so we have 3 bootloaders all supplied as part of the BSP and when building the install media we say which one to write.
Even that, in theory, could be avoided, at least on SoCs with the same ISA by improving u-boot a bit to make stuff like clocks configurable from data (the u-boot device tree) like the kernel already does. This may one day be possible once u-boot completely adopts the driver model.
Granted, UEFI is grotesquely complicated. Probably you could replace most of it with a EEPROM that has a mapping of device ID to memory address, and some instructions how to speak to the embedded controller (basically, ACPI).
Unfortunately, UEFI/ACPI or simliar seems to be going nowhere in the ARM world, so it doesn't seem installing Windows/Linux is going to be as easy on ARM as on x86 anytime soon.