[lkml]   [2009]   [Apr]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
    Subjectmicroblaze: Statically linking device tree blobs into the kernel
    To MicroBlazers and other interested parties:

    Currently the MicroBlaze kernel boot-time ABI requires r7 to point to
    a valid DTB, whereupon in early kernel setup the DTB is copied to a
    statically allocated 16k memory region inside the kernel. From there
    it is later queried by the platform startup code.

    For simple boot scenarios the ability to statically bind a DTB into
    the kernel image would clearly be useful. In PPC land, this is
    achieved through the simpleboot bootloader that lives in
    arch/powerpc/boot. The DTB becomes part of the simpleboot payload,
    and is passed to the kernel through the normal means.

    I'm not convinced duplicating this for MicroBlaze is a good idea, I
    think it would be overkill. However, the make syntax that PPC uses to
    achieve DTB binding is quite nice:

    $ make simpleImage.<board>

    which binds arch/powerpc/boot/dts/<board>.dts into the boot payload.

    My feeling is that we should make use of the fact that the DTB region
    is statically allocated in the MicroBlaze kernel anyway. From

    . = ALIGN (4) ;
    _fdt_start = . ; /* place for fdt blob */
    . = . + 0x4000;
    _fdt_end = . ;

    and in head.S, the DTB at r7 is copied into place at _fdt_start

    /* save fdt to kernel location */
    /* r7 stores pointer to fdt blob */
    beqi r7, no_fdt_arg
    or r11, r0, r0 /* incremment */
    ori r4, r0, TOPHYS(_fdt_start) /* save bram context */
    ori r3, r0, (0x4000 - 4)
    <simple copy loop>

    Since this memory is already allocated in the kernel image but is
    normally just zeros, to bind a DTB to the kernel we could just store
    it in-situ. This way, if a non-zero r7 is passed in at boot time,
    head.S will naturally overwrite (and thus override) the "default" DTB
    that was inside the kernel image.

    What I'm not so sure about is how best to achieve this in the kbuild
    sequence. I see two options:

    (a) use .incbin in a .S file, similar to how the initramfs gets
    linked in in /usr/Makefile etc, or
    (b) use objcopy to manipulate vmlinux after final link, by directly
    inserting the DTB into the appropriate ELF section.

    (a) seems nice because it means that our standard make targets, such
    as linux.bin etc, would still work unchanged. (b) seems to go a bit
    against the grain of kbuild, but maybe I'm wrong there.

    I've hacked around with (a) a bit, part of the problem is that it
    seems arch/microblaze/Makefile would need something like

    core-y += arch/microblaze/boot

    because the DTB "object file" must be ready before final vmlinux link.

    Instead of how it's done now (and in PPC), which is:

    $(BOOT_TARGETS): vmlinux
    $(Q)$(MAKE) ARCH=ppc64 $(build)=$(boot) $(patsubst %,$(boot)/%,$@)

    where vmlinux is a dependency of the whole simpleImage/DTB binding process.

    Anyway input on both the approach, and how to achieve it, would be
    greatly appreciated before we go working to deeply on the


    John Williams,
    PetaLogix - Linux Solutions for a Reconfigurable World
    w: p: +61-7-30090663 f: +61-7-30090663

     \ /
      Last update: 2009-04-27 06:27    [W:0.021 / U:79.024 seconds]
    ©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site