fdtmem.h File Reference

Flattened Device Tree memory map. More...

#include <stdint.h>

Go to the source code of this file.

Macros
#define	MEMMAP_PREFIX_fdt   __fdt_

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static	__attribute__ ((always_inline)) void MEMMAP_INLINE(fdt
	Synchronise in-use regions with the externally visible system memory map. More...
static	memmap_sync (void)
	Synchronise in-use regions with the externally visible system memory map. More...
physaddr_t	fdtmem_relocate (struct fdt_header *hdr, physaddr_t max)
	Find a relocation address for iPXE. More...
int	fdtmem_register (struct fdt_header *hdr, physaddr_t max)
	Copy and register system device tree. More...

Detailed Description

Flattened Device Tree memory map.

Definition in file fdtmem.h.

Macro Definition Documentation

MEMMAP_PREFIX_fdt

#define MEMMAP_PREFIX_fdt   __fdt_

Definition at line 17 of file fdtmem.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

__attribute__()

static __attribute__ ( (always_inline)  )

inlinestatic

Synchronise in-use regions with the externally visible system memory map.

memmap_sync()

static memmap_sync

(

void

)

Synchronise in-use regions with the externally visible system memory map.

In environments such as x86 BIOS, we need to patch the global system memory map to hide our in-use regions, since there is no other way to communicate this information to external code.

Definition at line 25 of file fdtmem.h.

                                            {
        /* Nothing to do */
}

fdtmem_relocate()

physaddr_t fdtmem_relocate	(	struct fdt_header *	hdr,
		physaddr_t	max
	)

Find a relocation address for iPXE.

Parameters

hdr	FDT header
max	Maximum accessible physical address

Return values

new	New physical address for relocation

Find a suitably aligned address towards the top of existent 32-bit memory to which iPXE may be relocated, along with a copy of the system device tree.

This function may be called very early in initialisation, before .data is writable or .bss has been zeroed. Neither this function nor any function that it calls may write to or rely upon the zero initialisation of any static variables.

Definition at line 264 of file fdtmem.c.

                                                                      {
        struct fdt fdt;
        struct memmap_region region;
        physaddr_t addr;
        physaddr_t next;
        physaddr_t old;
        physaddr_t new;
        physaddr_t try;
        size_t len;
        int rc;

        /* Sanity check */
        assert ( ( max_align & ( max_align - 1 ) ) == 0 );

        /* Get current physical address */
        old = virt_to_phys ( _prefix );

        /* Parse FDT */
        if ( ( rc = fdt_parse ( &fdt, hdr, -1UL ) ) != 0 ) {
                DBGC ( hdr, "FDTMEM could not parse FDT: %s\n",
                       strerror ( rc ) );
                /* Refuse relocation if we have no FDT */
                return old;
        }

        /* Determine required length */
        len = fdtmem_len ( &fdt );
        assert ( len > 0 );
        DBGC ( hdr, "FDTMEM requires %#zx + %#zx => %#zx bytes for "
               "relocation\n", memsz, fdt.len, len );

        /* Limit relocation to 32-bit address space
         *
         * Devices with only 32-bit DMA addressing are relatively
         * common even on systems with 64-bit CPUs.  Limit relocation
         * of iPXE to 32-bit address space so that I/O buffers and
         * other DMA allocations will be accessible by 32-bit devices.
         */
        if ( max > FDTMEM_MAX32 )
                max = FDTMEM_MAX32;

        /* Construct memory map and choose a relocation address */
        new = old;
        for ( addr = 0, next = 1 ; next ; addr = next ) {

                /* Describe region and in-use memory */
                fdtmem_describe ( addr, max, &fdt, &region );
                memmap_update ( &region, old, memsz, MEMMAP_FL_USED, "iPXE" );
                memmap_update ( &region, virt_to_phys ( hdr ), fdt.len,
                                MEMMAP_FL_RESERVED, "FDT" );
                next = ( region.max + 1 );

                /* Dump region descriptor (for debugging) */
                DBGC_MEMMAP ( hdr, &region );
                assert ( region.max >= region.min );

                /* Use highest possible region */
                if ( memmap_is_usable ( &region ) &&
                     ( ( next == 0 ) || ( next >= len ) ) ) {

                        /* Determine candidate address after alignment */
                        try = ( ( next - len ) & ~( max_align - 1 ) );

                        /* Use this address if within region */
                        if ( try >= addr )
                                new = try;
                }
        }

        DBGC ( hdr, "FDTMEM relocating %#08lx => [%#08lx,%#08lx]\n",
               old, new, ( ( physaddr_t ) ( new + len - 1 ) ) );
        return new;
}

References _prefix, addr, assert(), DBGC, DBGC_MEMMAP, fdt_parse(), fdtmem_describe(), fdtmem_len(), FDTMEM_MAX32, hdr, fdt::len, len, max, memmap_region::max, max_align, MEMMAP_FL_RESERVED, MEMMAP_FL_USED, memmap_is_usable(), memmap_update(), memsz, memmap_region::min, next, old, rc, and strerror().

fdtmem_register()

int fdtmem_register	(	struct fdt_header *	hdr,
		physaddr_t	max
	)

Copy and register system device tree.

Parameters

hdr	FDT header
max	Maximum accessible physical address

Return values

rc	Return status code

Definition at line 345 of file fdtmem.c.

                                                               {
        struct fdt_header *copy;
        struct fdt fdt;
        int rc;

        /* Record maximum accessible physical address */
        fdtmem_max = max;

        /* Parse FDT to obtain length */
        if ( ( rc = fdt_parse ( &fdt, hdr, -1UL ) ) != 0 ) {
                DBGC ( hdr, "FDTMEM could not parse FDT: %s\n",
                       strerror ( rc ) );
                return rc;
        }

        /* Copy device tree to end of iPXE image */
        copy = ( ( void * ) _end );
        memcpy ( copy, hdr, fdt.len );

        /* Update in-use memory region */
        memmap_use ( &fdtmem_used, virt_to_phys ( _prefix ),
                     fdtmem_len ( &fdt ) );

        /* Register copy as system device tree */
        if ( ( rc = fdt_parse ( &sysfdt, copy, -1UL ) ) != 0 ) {
                DBGC ( hdr, "FDTMEM could not register FDT: %s\n",
                       strerror ( rc ) );
                return rc;
        }
        assert ( sysfdt.len == fdt.len );

        /* Dump system memory map (for debugging) */
        memmap_dump_all ( 1 );

        return 0;
}

References _end, _prefix, assert(), DBGC, fdt_parse(), fdtmem_len(), fdtmem_max, hdr, fdt::len, max, memcpy(), memmap_dump_all(), memmap_use(), rc, strerror(), and sysfdt.