Let the platform mmu_map_physical_memory the initrd region, and
reserve it before calling mmu_init. This removes another hardcoded
address, since e.g. U-Boot gets the address from the uImage file.
* Cleanup the SD card image building to allow jam -q @bootstrap-mmc to
work.
There are a few remaining tricks before you can safely build an image:
* This uses a non-POSIX du option, and is only tested with Linux du
only (Linux is the only supported system to run bootstrap builds,
anyway)
* The Python recipe in haikuports.cross is known to not build on
Debian/Ubuntu, but work fine on OpenSuse. There is a patch available in
haikuports bugtracker to allow the reverse.
* You need to populate the haikuports repo package list with some
packages (which don't exist yet) to make the build system happy. But our
git hook to generate the repositories is preventnig me to share this
hack.
Once built, the image currently crashes early in the kernel execution.
On to debug that!
Ideally, we would only need to set this in build/jam/board/*, but the
flags set there are not passed to the build of packages. The default is
using some early ARM variant, for which gcc lacks some more atomic
operations and emits calls to helper functions we don't implement.
Setting the default architecture avoids this, as all packages will now
be built to target the Cortex-A8.
Also set the proper VFP version in BeagleBoard config file.
Note this breaks the Verdex and Pi builds, but ARMv7 is what we should
focus on for now. We can try to make older archs work after finishing
the m68k port.
* This avoids mixup of the soft/hard float libs
* It also means we can use the hard-float libs for targets that supports
it
* Again, we could introduce an arm_softfp compiler for targets that
don't have floating point support, with a different gcc build.
* Don't assume verdex as it isn't clear this was
occurring.
* Make an educated guess on HAIKU_BOOT_PLATFORM
based on provided board (but still allow it to
be overridden)
* Error out if user doesn't populate
HAIKU_BOOT_PLATFORM or enters an unknown board
name.
* You need to add "-sHAIKU_BOOT_BOARD=xxx" to
your jam to build for the proper ARM device.
* Rename beagle to beagleboneblk as per the
documentation.
* ArchitectureRules define a variable named HAIKU_ASFLAGS, so other
Jamfiles can append to it.
* But, TARGET_ASFLAGS was used instead in the single place where we
tried to make use of this (the verdex BoardSetup), and in the As rule
* Moreover, the As rule used $(architecture) instead of
$(TARGET_PACKAGING_ARCH) (I suspect a bogus copypaste?). So, it never
actually made use of the flags
With this working, add the proper flags to the BeagleBoard BoardSetup,
so we implement atomic operations the ARMv7 way (no need to syscall).
This helps with compiling, as the As and Cc/Cpp rules now agree on the
defines and the atomic implementation to use.
The ones with ARCH extension are used for setting up the KERNEL
ones, so no need to try and set both.
Also, the verdex target was not setting the ARCH one, and therefore
never configured gcc for ARMv5.
This is especially important for the assembler code in the kernel,
since it enables workarounds for some critical errata related to
exception handling.
* All packaging architecture dependent variables do now have a
respective suffix and are set up for each configured packaging
architecture, save for the kernel and boot loader variables, which
are still only set up for the primary architecture.
For convenience TARGET_PACKAGING_ARCH, TARGET_ARCH, TARGET_LIBSUPC++,
and TARGET_LIBSTDC++ are set to the respective values for the primary
packaging architecture by default.
* Introduce a set of MultiArch* rules to help with building targets for
multiple packaging architectures. Generally the respective targets are
(additionally) gristed with the packaging architecture. For libraries
the additional grist is usually omitted for the primary architecture
(e.g. libroot.so and <x86>libroot.so for x86_gcc2/x86 hybrid), so that
Jamfiles for targets built only for the primary architecture don't
need to be changed.
* Add multi-arch build support for all targets needed for the stage 1
cross devel package as well as for libbe (untested).
An archive (ramfs) to be loaded can be specified in the raspberry pi
config.txt with a certain base address. We can use this to put our
floppy boot archive into memory on startup.
During the start procedure we now map that archive so we can later
load the kernel from it.
* our current gcc can't be built with multilib for ppc anyway,
* this allows going further on real hardware, though dprintf() sends wrong data to the serial port.
* since we include BoardSetup earlier now, the TARGET_* flags were discarded. Use HAIKU_* instead.
* Add variables to hold the default entry point and the desired uimage OS emulation.
* Pi firmware was updated to note that Broadcom
had to be included with firmware blobs.
* While we have permission from Eben to have the
blobs in-tree, they are now offically on github
in a fixed location removing the need to have
these in-tree.
* Clean up BoardConfig, note firmware URL and
files needed
* Update info.txt with how Haiku boot process works
* Thanks go out to Simon Arlott for replacing
the first32k.bin blob with assembly removing
the need for first32k.bin hack.
* This assembly is a modified version removing
the Linux kernel boot args.
* haiku_loader renamed to kernel.img will boot
on Raspberry Pi directly.
* Version 17-02-2012
* Used to initialize the Raspberry Pi GPU and boot it
* License is permissive, I've also included the
confirmation email on this license.
* Little bootloader documentation.
* Still nothing to get excited about, preliminary.
Workaround for ld using 32k alignment between ELF segments, until a proper fix is found.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32429 a95241bf-73f2-0310-859d-f6bbb57e9c96
