Flattened Device Tree memory map. More...

#include <stdint.h>

Macros
#define	MEMMAP_PREFIX_fdt __fdt_

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

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 18 of file fdtmem.h.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ attribute()

__attribute__ ( (always_inline) )

inlinestatic

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

◆ memmap_sync()

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 26 of file fdtmem.h.

                                            {
        /* Nothing to do */
}

References memmap_sync().

Referenced by memmap_sync(), PROVIDE_MEMMAP(), PROVIDE_MEMMAP_INLINE(), and PROVIDE_MEMMAP_INLINE().

◆ fdtmem_relocate()

physaddr_t fdtmem_relocate	(	struct fdt_header *	hdr,
		physaddr_t	max )

extern

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 )

extern

Copy and register system device tree.