fdt.c File Reference

Flattened Device Tree. More...

#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <assert.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/image.h>
#include <ipxe/uaccess.h>
#include <ipxe/umalloc.h>
#include <ipxe/fdt.h>

Go to the source code of this file.

Macros
#define	FDT_INSERT_PAD   1024
	Amount of free space to add whenever we have to reallocate a tree.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	fdt_permitted (char ch)
	Check if character is permitted in a name.
static int	fdt_match (const struct fdt_descriptor *desc, const char *name)
	Compare node name.
int	fdt_describe (struct fdt *fdt, unsigned int offset, struct fdt_descriptor *desc)
	Describe device tree token.
static int	fdt_next (struct fdt *fdt, struct fdt_descriptor *desc)
	Describe next device tree token.
static int	fdt_enter (struct fdt *fdt, unsigned int offset, struct fdt_descriptor *desc)
	Enter node.
static int	fdt_depth (struct fdt *fdt, unsigned int offset, unsigned int target)
	Find node relative depth.
int	fdt_parent (struct fdt *fdt, unsigned int offset, unsigned int *parent)
	Find parent node.
static int	fdt_child (struct fdt *fdt, unsigned int offset, const char *name, unsigned int *child)
	Find child node.
static int	fdt_end (struct fdt *fdt, unsigned int offset, unsigned int *end)
	Find end of node.
int	fdt_path (struct fdt *fdt, const char *path, unsigned int *offset)
	Find node by path.
int	fdt_alias (struct fdt *fdt, const char *name, unsigned int *offset)
	Find node by alias.
static int	fdt_property (struct fdt *fdt, unsigned int offset, const char *name, struct fdt_descriptor *desc)
	Find property.
const char *	fdt_strings (struct fdt *fdt, unsigned int offset, const char *name, unsigned int *count)
	Find strings property.
const char *	fdt_string (struct fdt *fdt, unsigned int offset, const char *name)
	Find string property.
int	fdt_cells (struct fdt *fdt, unsigned int offset, const char *name, unsigned int index, unsigned int count, uint64_t *value)
	Get integer property.
int	fdt_u64 (struct fdt *fdt, unsigned int offset, const char *name, uint64_t *value)
	Get 64-bit integer property.
int	fdt_u32 (struct fdt *fdt, unsigned int offset, const char *name, uint32_t *value)
	Get 32-bit integer property.
uint32_t	fdt_phandle (struct fdt *fdt, unsigned int offset)
	Get package handle (phandle) property.
void	fdt_reg_cells (struct fdt *fdt, unsigned int offset, struct fdt_reg_cells *regs)
	Get region cell size specification.
int	fdt_parent_reg_cells (struct fdt *fdt, unsigned int offset, struct fdt_reg_cells *regs)
	Get parent region cell size specification.
int	fdt_reg_count (struct fdt *fdt, unsigned int offset, struct fdt_reg_cells *regs)
	Get number of regions.
int	fdt_reg_address (struct fdt *fdt, unsigned int offset, struct fdt_reg_cells *regs, unsigned int index, uint64_t *address)
	Get region address.
int	fdt_reg_size (struct fdt *fdt, unsigned int offset, struct fdt_reg_cells *regs, unsigned int index, uint64_t *size)
	Get region size.
int	fdt_reg (struct fdt *fdt, unsigned int offset, uint64_t *region)
	Get unsized single-entry region address.
int	fdt_mac (struct fdt *fdt, unsigned int offset, struct net_device *netdev)
	Get MAC address from property.
int	fdt_parse (struct fdt *fdt, struct fdt_header *hdr, size_t max_len)
	Parse device tree.
static int	fdt_parse_image (struct fdt *fdt, struct image *image)
	Parse device tree image.
static int	fdt_insert (struct fdt *fdt, unsigned int offset, size_t len)
	Insert empty space.
static void	fdt_nop (struct fdt *fdt, unsigned int offset, size_t len)
	Fill space in structure block with FDT_NOP.
static int	fdt_insert_nop (struct fdt *fdt, unsigned int offset, size_t len)
	Insert FDT_NOP padded space in structure block.
static int	fdt_insert_string (struct fdt *fdt, const char *string, unsigned int *offset)
	Insert string in strings block.
static int	fdt_ensure_child (struct fdt *fdt, unsigned int offset, const char *name, unsigned int *child)
	Ensure child node exists.
static int	fdt_set (struct fdt *fdt, unsigned int offset, const char *name, const void *data, size_t len)
	Set property value.
static int	fdt_urealloc (struct fdt *fdt, size_t len)
	Reallocate device tree via urealloc()
static int	fdt_bootargs (struct fdt *fdt, const char *cmdline, physaddr_t initrd, size_t initrd_len)
	Populate device tree with boot arguments.
int	fdt_create (struct fdt_header **hdr, const char *cmdline, physaddr_t initrd, size_t initrd_len)
	Create device tree.
void	fdt_remove (struct fdt_header *hdr)
	Remove device tree.
	REQUIRING_SYMBOL (fdt_describe)
	REQUIRE_OBJECT (config_fdt)

Variables
struct fdt	sysfdt
	The system flattened device tree (if present)
struct image_tag fdt_image	__image_tag
	The downloaded flattened device tree tag.

Detailed Description

Flattened Device Tree.

Definition in file fdt.c.

Macro Definition Documentation

FDT_INSERT_PAD

#define FDT_INSERT_PAD   1024

Amount of free space to add whenever we have to reallocate a tree.

Definition at line 53 of file fdt.c.

Referenced by fdt_insert().

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

fdt_permitted()

int fdt_permitted ( char ch )

static

Check if character is permitted in a name.

Parameters

ch

Character

Return values

is_permitted

Character is permitted in a name

Definition at line 61 of file fdt.c.

                                     {
        static const char permitted[] = ",._+?#-";
 
        return ( isalnum ( ch ) || strchr ( permitted, ch ) );
}

References ch, isalnum(), and strchr().

Referenced by fdt_match().

fdt_match()

int fdt_match ( const struct fdt_descriptor * desc, const char * name )

static

Compare node name.

Parameters

desc	Token descriptor
name	Name (terminated by NUL or any non-permitted character)

Return values

is_match

Name matches token descriptor

Definition at line 74 of file fdt.c.

                                                                             {
        size_t len = strlen ( desc->name );
 
        /* Check name and terminator */
        return ( ( memcmp ( desc->name, name, len ) == 0 ) &&
                 ( ! ( name[len] && fdt_permitted ( name[len] ) ) ) );
}

References desc, fdt_permitted(), len, memcmp(), name, and strlen().

Referenced by fdt_child(), and fdt_property().

fdt_describe()

int fdt_describe	(	struct fdt *	fdt,
		unsigned int	offset,
		struct fdt_descriptor *	desc )

Describe device tree token.

Parameters

fdt	Device tree
offset	Offset within structure block
desc	Token descriptor to fill in

Return values

rc	Return status code

Definition at line 90 of file fdt.c.

                                                 {
        const fdt_token_t *token;
        const void *data;
        const struct fdt_prop *prop;
        unsigned int name_off;
        size_t remaining;
        size_t len;
 
        /* Sanity checks */
        assert ( offset <= fdt->len );
        assert ( ( offset & ( FDT_STRUCTURE_ALIGN - 1 ) ) == 0 );
 
        /* Initialise descriptor */
        memset ( desc, 0, sizeof ( *desc ) );
        desc->offset = offset;
 
        /* Locate token and calculate remaining space */
        token = ( fdt->raw + fdt->structure + offset );
        remaining = ( fdt->len - offset );
        if ( remaining < sizeof ( *token ) ) {
                DBGC ( fdt, "FDT truncated tree at +%#04x\n", offset );
                return -EINVAL;
        }
        remaining -= sizeof ( *token );
        data = ( ( ( const void * ) token ) + sizeof ( *token ) );
        len = 0;
 
        /* Handle token */
        switch ( *token ) {
 
        case cpu_to_be32 ( FDT_BEGIN_NODE ):
 
                /* Start of node */
                desc->name = data;
                len = ( strnlen ( desc->name, remaining ) + 1 /* NUL */ );
                if ( remaining < len ) {
                        DBGC ( fdt, "FDT unterminated node name at +%#04x\n",
                               offset );
                        return -EINVAL;
                }
                desc->depth = +1;
                break;
 
        case cpu_to_be32 ( FDT_END_NODE ):
 
                /* End of node */
                desc->depth = -1;
                break;
 
        case cpu_to_be32 ( FDT_PROP ):
 
                /* Property */
                prop = data;
                if ( remaining < sizeof ( *prop ) ) {
                        DBGC ( fdt, "FDT truncated property at +%#04x\n",
                               offset );
                        return -EINVAL;
                }
                desc->data = ( ( ( const void * ) prop ) + sizeof ( *prop ) );
                desc->len = be32_to_cpu ( prop->len );
                len = ( sizeof ( *prop ) + desc->len );
                if ( remaining < len ) {
                        DBGC ( fdt, "FDT overlength property at +%#04x\n",
                               offset );
                        return -EINVAL;
                }
                name_off = be32_to_cpu ( prop->name_off );
                if ( name_off > fdt->strings_len ) {
                        DBGC ( fdt, "FDT property name outside strings "
                               "block at +%#04x\n", offset );
                        return -EINVAL;
                }
                desc->name = ( fdt->raw + fdt->strings + name_off );
                break;
 
        case cpu_to_be32 ( FDT_NOP ):
 
                /* Do nothing */
                break;
 
        default:
 
                /* Unrecognised or unexpected token */
                DBGC ( fdt, "FDT unexpected token %#08x at +%#04x\n",
                       be32_to_cpu ( *token ), offset );
                return -EINVAL;
        }
 
        /* Calculate offset to next token */
        len = ( ( len + FDT_STRUCTURE_ALIGN - 1 ) &
                ~( FDT_STRUCTURE_ALIGN - 1 ) );
        offset += ( sizeof ( *token ) + len );
        desc->next = offset;
 
        /* Sanity checks */
        assert ( offset <= fdt->len );
 
        return 0;
}

References assert, be32_to_cpu, cpu_to_be32, data, DBGC, desc, EINVAL, FDT_BEGIN_NODE, FDT_END_NODE, FDT_NOP, FDT_PROP, FDT_STRUCTURE_ALIGN, fdt::len, fdt_prop::len, len, memset(), fdt_prop::name_off, offset, fdt::raw, fdt::strings, fdt::strings_len, strnlen(), fdt::structure, and token.

Referenced by dt_probe_children(), dt_probe_node(), fdt_enter(), fdt_next(), fdt_test_exec(), fdtmem_update_node(), and REQUIRING_SYMBOL().

fdt_next()

int fdt_next ( struct fdt * fdt, struct fdt_descriptor * desc )

static

Describe next device tree token.

Parameters

fdt	Device tree
desc	Token descriptor to update

Return values

rc	Return status code

Definition at line 198 of file fdt.c.

                                                                     {
 
        /* Describe next token */
        return fdt_describe ( fdt, desc->next, desc );
}

References desc, and fdt_describe().

Referenced by fdt_child(), fdt_depth(), fdt_end(), fdt_parent(), and fdt_property().

fdt_enter()

int fdt_enter ( struct fdt * fdt, unsigned int offset, struct fdt_descriptor * desc )

static

Enter node.

Parameters

fdt	Device tree
offset	Starting node offset
desc	Begin node descriptor to fill in

Return values

rc	Return status code

Definition at line 212 of file fdt.c.

                                                     {
        int rc;
 
        /* Find begin node token */
        for ( ; ; offset = desc->next ) {
 
                /* Describe token */
                if ( ( rc = fdt_describe ( fdt, offset, desc ) ) != 0 ) {
                        DBGC ( fdt, "FDT +%#04x has malformed node: %s\n",
                               offset, strerror ( rc ) );
                        return rc;
                }
 
                /* Check for begin node token */
                if ( desc->depth > 0 )
                        return 0;
 
                /* Check for non-NOPs */
                if ( desc->depth ) {
                        DBGC ( fdt, "FDT +%#04x has spurious node end at "
                               "+%#04x\n", offset, desc->offset );
                        return -EINVAL;
                }
                if ( desc->name ) {
                        DBGC ( fdt, "FDT +%#04x has spurious property at "
                               "+%#04x\n", offset, desc->offset );
                        return -EINVAL;
                }
        }
}

References DBGC, desc, EINVAL, fdt_describe(), offset, rc, and strerror().

Referenced by fdt_child(), fdt_depth(), fdt_end(), fdt_parent(), fdt_property(), and fdt_set().

fdt_depth()

int fdt_depth ( struct fdt * fdt, unsigned int offset, unsigned int target )

static

Find node relative depth.

Parameters

fdt	Device tree
offset	Starting node offset
target	Target node offset

Return values

depth

Depth, or negative error

Definition at line 252 of file fdt.c.

                                             {
        struct fdt_descriptor desc;
        int depth;
        int rc;
 
        /* Enter node */
        if ( ( rc = fdt_enter ( fdt, offset, &desc ) ) != 0 )
                return rc;
 
        /* Find target node */
        for ( depth = 0 ; depth >= 0 ; depth += desc.depth ) {
 
                /* Describe token */
                if ( ( rc = fdt_next ( fdt, &desc ) ) != 0 ) {
                        DBGC ( fdt, "FDT +%#04x has malformed node: %s\n",
                               offset, strerror ( rc ) );
                        return rc;
                }
 
                /* Check for target node */
                if ( desc.offset == target ) {
                        DBGC2 ( fdt, "FDT +%#04x has descendant node +%#04x "
                                "at depth +%d\n", offset, target, depth );
                        return depth;
                }
        }
 
        DBGC ( fdt, "FDT +#%04x has no descendant node +%#04x\n",
               offset, target );
        return -ENOENT;
}

References DBGC, DBGC2, fdt_descriptor::depth, desc, ENOENT, fdt_enter(), fdt_next(), offset, rc, and strerror().

Referenced by fdt_parent().

fdt_parent()

int fdt_parent	(	struct fdt *	fdt,
		unsigned int	offset,
		unsigned int *	parent )

Find parent node.

Parameters

fdt	Device tree
offset	Starting node offset
parent	Parent node offset to fill in

Return values

rc	Return status code

Definition at line 293 of file fdt.c.

                                                                              {
        struct fdt_descriptor desc;
        int pdepth;
        int depth;
        int rc;
 
        /* Find depth from root of tree */
        depth = fdt_depth ( fdt, 0, offset );
        if ( depth < 0 ) {
                rc = depth;
                return rc;
        }
        pdepth = ( depth - 1 );
 
        /* Enter root node */
        if ( ( rc = fdt_enter ( fdt, 0, &desc ) ) != 0 )
                return rc;
        *parent = desc.offset;
 
        /* Find parent node */
        for ( depth = 0 ; depth >= 0 ; depth += desc.depth ) {
 
                /* Describe token */
                if ( ( rc = fdt_next ( fdt, &desc ) ) != 0 ) {
                        DBGC ( fdt, "FDT +%#04x has malformed node: %s\n",
                               offset, strerror ( rc ) );
                        return rc;
                }
 
                /* Record possible parent node */
                if ( ( depth == pdepth ) && desc.name && ( ! desc.data ) )
                        *parent = desc.offset;
 
                /* Check for target node */
                if ( desc.offset == offset ) {
                        DBGC2 ( fdt, "FDT +%#04x has parent node at +%#04x\n",
                                offset, *parent );
                        return 0;
                }
        }
 
        DBGC ( fdt, "FDT +#%04x has no parent node\n", offset );
        return -ENOENT;
}

References DBGC, DBGC2, fdt_descriptor::depth, desc, ENOENT, fdt_depth(), fdt_enter(), fdt_next(), offset, rc, and strerror().

Referenced by fdt_parent_reg_cells(), and fdt_test_exec().

fdt_child()

int fdt_child ( struct fdt * fdt, unsigned int offset, const char * name, unsigned int * child )

static

Find child node.

Parameters

fdt	Device tree
offset	Starting node offset
name	Node name
child	Child node offset to fill in

Return values

rc	Return status code

Definition at line 347 of file fdt.c.

                                             {
        struct fdt_descriptor desc;
        int depth;
        int rc;
 
        /* Enter node */
        if ( ( rc = fdt_enter ( fdt, offset, &desc ) ) != 0 )
                return rc;
 
        /* Find child node */
        for ( depth = 0 ; depth >= 0 ; depth += desc.depth ) {
 
                /* Describe token */
                if ( ( rc = fdt_next ( fdt, &desc ) ) != 0 ) {
                        DBGC ( fdt, "FDT +%#04x has malformed node: %s\n",
                               offset, strerror ( rc ) );
                        return rc;
                }
 
                /* Check for matching immediate child node */
                if ( ( depth == 0 ) && desc.name && ( ! desc.data ) ) {
                        DBGC2 ( fdt, "FDT +%#04x has child node \"%s\" at "
                                "+%#04x\n", offset, desc.name, desc.offset );
                        assert ( desc.depth > 0 );
                        if ( fdt_match ( &desc, name ) ) {
                                *child = desc.offset;
                                return 0;
                        }
                }
        }
 
        DBGC2 ( fdt, "FDT +%#04x has no child node \"%s\"\n", offset, name );
        return -ENOENT;
}

References assert, DBGC, DBGC2, fdt_descriptor::depth, desc, ENOENT, fdt_enter(), fdt_match(), fdt_next(), name, offset, rc, and strerror().

Referenced by fdt_alias(), fdt_ensure_child(), fdt_parse(), and fdt_path().

fdt_end()

int fdt_end ( struct fdt * fdt, unsigned int offset, unsigned int * end )

static

Find end of node.

Parameters

fdt	Device tree
offset	Starting node offset
end	End of node offset to fill in

Return values

rc	Return status code

Definition at line 391 of file fdt.c.

                                         {
        struct fdt_descriptor desc;
        int depth;
        int rc;
 
        /* Enter node */
        if ( ( rc = fdt_enter ( fdt, offset, &desc ) ) != 0 )
                return rc;
 
        /* Find end of this node */
        for ( depth = 0 ; depth >= 0 ; depth += desc.depth ) {
 
                /* Describe token */
                if ( ( rc = fdt_next ( fdt, &desc ) ) != 0 ) {
                        DBGC ( fdt, "FDT +%#04x has malformed node: %s\n",
                               offset, strerror ( rc ) );
                        return rc;
                }
        }
 
        /* Record end offset */
        *end = desc.offset;
        DBGC2 ( fdt, "FDT +%#04x has end at +%#04x\n", offset, *end );
        return 0;
}

References DBGC, DBGC2, fdt_descriptor::depth, desc, end, fdt_enter(), fdt_next(), offset, rc, and strerror().

Referenced by fdt_ensure_child().

fdt_path()

int fdt_path	(	struct fdt *	fdt,
		const char *	path,
		unsigned int *	offset )

Find node by path.

Parameters

fdt	Device tree
path	Node path
offset	Offset to fill in

Return values

rc	Return status code

Definition at line 426 of file fdt.c.

                                                                         {
        const char *tmp = path;
        int rc;
 
        /* Initialise offset */
        *offset = 0;
 
        /* Traverse tree one path segment at a time */
        while ( 1 ) {
 
                /* Skip any leading '/' */
                while ( *tmp == '/' )
                        tmp++;
 
                /* Terminate if there are no more path components */
                if ( ! *tmp )
                        break;
 
                /* Find child */
                if ( ( rc = fdt_child ( fdt, *offset, tmp, offset ) ) != 0 )
                        return rc;
 
                /* Move to next path component, if any */
                tmp = strchr ( tmp, '/' );
                if ( ! tmp )
                        break;
        }
 
        DBGC2 ( fdt, "FDT found path \"%s\" at +%#04x\n", path, *offset );
        return 0;
}

References DBGC2, fdt_child(), offset, rc, strchr(), and tmp.

Referenced by fdt_alias(), fdt_test_exec(), fdtcon_default(), and fdtmem_update_tree().

fdt_alias()

int fdt_alias	(	struct fdt *	fdt,
		const char *	name,
		unsigned int *	offset )

Find node by alias.

Parameters

fdt	Device tree
name	Alias name
offset	Offset to fill in

Return values

rc	Return status code

Definition at line 466 of file fdt.c.

                                                                          {
        const char *alias;
        int rc;
 
        /* Locate "/aliases" node */
        if ( ( rc = fdt_child ( fdt, 0, "aliases", offset ) ) != 0 )
                return rc;
 
        /* Locate alias property */
        if ( ( alias = fdt_string ( fdt, *offset, name ) ) == NULL )
                return -ENOENT;
        DBGC ( fdt, "FDT alias \"%s\" is \"%s\"\n", name, alias );
 
        /* Locate aliased node */
        if ( ( rc = fdt_path ( fdt, alias, offset ) ) != 0 )
                return rc;
 
        return 0;
}

References DBGC, ENOENT, fdt_child(), fdt_path(), fdt_string(), name, NULL, offset, and rc.

Referenced by fdt_test_exec(), fdtcon_default(), and smscusb_fdt_fetch_mac().

fdt_property()

int fdt_property ( struct fdt * fdt, unsigned int offset, const char * name, struct fdt_descriptor * desc )

static

Find property.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name
desc	Token descriptor to fill in

Return values

rc	Return status code

Definition at line 495 of file fdt.c.

                                                                          {
        int depth;
        int rc;
 
        /* Enter node */
        if ( ( rc = fdt_enter ( fdt, offset, desc ) ) != 0 )
                return rc;
 
        /* Find property */
        for ( depth = 0 ; depth == 0 ; depth += desc->depth ) {
 
                /* Describe token */
                if ( ( rc = fdt_next ( fdt, desc ) ) != 0 ) {
                        DBGC ( fdt, "FDT +%#04x has malformed node: %s\n",
                               offset, strerror ( rc ) );
                        return rc;
                }
 
                /* Check for matching immediate child property */
                if ( desc->data ) {
                        DBGC2 ( fdt, "FDT +%#04x has property \"%s\" at "
                                "+%#04x len %#zx\n", offset, desc->name,
                                desc->offset, desc->len );
                        assert ( desc->depth == 0 );
                        if ( fdt_match ( desc, name ) ) {
                                DBGC2_HDA ( fdt, 0, desc->data, desc->len );
                                return 0;
                        }
                }
        }
 
        DBGC2 ( fdt, "FDT +%#04x has no property \"%s\"\n", offset, name );
        return -ENOENT;
}

References assert, DBGC, DBGC2, DBGC2_HDA, fdt_descriptor::depth, desc, ENOENT, fdt_enter(), fdt_match(), fdt_next(), name, offset, rc, and strerror().

Referenced by fdt_cells(), fdt_mac(), fdt_reg_count(), fdt_set(), and fdt_strings().

fdt_strings()

const char * fdt_strings	(	struct fdt *	fdt,
		unsigned int	offset,
		const char *	name,
		unsigned int *	count )

Find strings property.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name
count	String count to fill in

Return values

string

String property, or NULL on error

Definition at line 540 of file fdt.c.

                                                                   {
        struct fdt_descriptor desc;
        const char *data;
        size_t len;
        int rc;
 
        /* Return a zero count on error */
        *count = 0;
 
        /* Find property */
        if ( ( rc = fdt_property ( fdt, offset, name, &desc ) ) != 0 )
                return NULL;
 
        /* Check NUL termination */
        data = desc.data;
        if ( desc.len && ( data[ desc.len - 1 ] != '\0' ) ) {
                DBGC ( fdt, "FDT unterminated string property \"%s\"\n",
                       name );
                return NULL;
        }
 
        /* Count number of strings */
        for ( len = desc.len ; len-- ; ) {
                if ( data[len] == '\0' )
                        (*count)++;
        }
 
        return data;
}

References count, data, DBGC, desc, fdt_property(), len, name, NULL, offset, and rc.

Referenced by dt_find_driver(), fdt_string(), and fdt_test_exec().

fdt_string()

const char * fdt_string	(	struct fdt *	fdt,
		unsigned int	offset,
		const char *	name )

Find string property.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name

Return values

string

String property, or NULL on error

Definition at line 579 of file fdt.c.

                                             {
        unsigned int count;
 
        /* Find strings property */
        return fdt_strings ( fdt, offset, name, &count );
}

References count, fdt_strings(), name, and offset.

Referenced by fdt_alias(), fdt_parse(), fdt_test_exec(), fdtcon_default(), and fdtmem_update_node().

fdt_cells()

int fdt_cells	(	struct fdt *	fdt,
		unsigned int	offset,
		const char *	name,
		unsigned int	index,
		unsigned int	count,
		uint64_t *	value )

Get integer property.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name
index	Starting cell index
count	Number of cells (or 0 to read all remaining cells)
value	Integer value to fill in

Return values

rc	Return status code

Definition at line 598 of file fdt.c.

                                                                          {
        struct fdt_descriptor desc;
        const uint32_t *cell;
        unsigned int total;
        int rc;
 
        /* Clear value */
        *value = 0;
 
        /* Find property */
        if ( ( rc = fdt_property ( fdt, offset, name, &desc ) ) != 0 )
                return rc;
        cell = desc.data;
 
        /* Determine number of cells */
        total = ( desc.len / sizeof ( *cell ) );
        if ( ( index > total ) || ( count > ( total - index ) ) ) {
                DBGC ( fdt, "FDT truncated integer \"%s\"\n", name );
                return -ERANGE;
        }
        if ( ! count )
                count = ( total - index );
        if ( count > ( sizeof ( *value ) / sizeof ( *cell ) ) ) {
                DBGC ( fdt, "FDT overlength integer \"%s\"\n", name );
                return -ERANGE;
        }
 
        /* Read value */
        for ( cell += index ; count ; cell++, count-- ) {
                *value <<= 32;
                *value |= be32_to_cpu ( *cell );
        }
 
        return 0;
}

References be32_to_cpu, count, DBGC, desc, ERANGE, fdt_property(), index, name, offset, rc, and value.

Referenced by fdt_reg_address(), fdt_reg_size(), fdt_test_exec(), and fdt_u64().

fdt_u64()

int fdt_u64	(	struct fdt *	fdt,
		unsigned int	offset,
		const char *	name,
		uint64_t *	value )

Get 64-bit integer property.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name
value	Integer value to fill in

Return values

rc	Return status code

Definition at line 644 of file fdt.c.

                                {
        int rc;
 
        /* Read value */
        if ( ( rc = fdt_cells ( fdt, offset, name, 0, 0, value ) ) != 0 )
                return rc;
 
        return 0;
}

References fdt_cells(), name, offset, rc, and value.

Referenced by fdt_test_exec(), and fdt_u32().

fdt_u32()

int fdt_u32	(	struct fdt *	fdt,
		unsigned int	offset,
		const char *	name,
		uint32_t *	value )

Get 32-bit integer property.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name
value	Integer value to fill in

Return values

rc	Return status code

Definition at line 664 of file fdt.c.

                                {
        uint64_t value64;
        int rc;
 
        /* Read value */
        if ( ( rc = fdt_u64 ( fdt, offset, name, &value64 ) ) != 0 )
                return rc;
 
        /* Check range */
        *value = value64;
        if ( *value != value64 ) {
                DBGC ( fdt, "FDT overlength 32-bit integer \"%s\"\n", name );
                return -ERANGE;
        }
 
        return 0;
}

References DBGC, ERANGE, fdt_u64(), name, offset, rc, and value.

Referenced by dwgpio_probe(), dwuart_probe(), fdt_phandle(), fdt_reg_cells(), and fdt_test_exec().

fdt_phandle()

uint32_t fdt_phandle	(	struct fdt *	fdt,
		unsigned int	offset )

Get package handle (phandle) property.

Parameters

fdt	Device tree
offset	Starting node offset

Return values

phandle

Package handle, or 0 on error

Definition at line 690 of file fdt.c.

                                                              {
        uint32_t phandle;
        int rc;
 
        /* Get "phandle" or "linux,phandle" property */
        if ( ( ( rc = fdt_u32 ( fdt, offset, "phandle", &phandle ) ) == 0 ) ||
             ( ( rc = fdt_u32 ( fdt, offset, "linux,phandle",
                                &phandle ) ) == 0 ) ) {
                assert ( phandle != 0 );
                return phandle;
        }
 
        return 0;
}

References assert, fdt_u32(), offset, and rc.

Referenced by dt_probe_node(), and fdt_test_exec().

fdt_reg_cells()

void fdt_reg_cells	(	struct fdt *	fdt,
		unsigned int	offset,
		struct fdt_reg_cells *	regs )

Get region cell size specification.

Parameters

fdt	Device tree
offset	Starting (parent) node offset
regs	Region cell size specification to fill in

Note that address-cells and size-cells are defined on the immediate parent node, rather than on the node with the "reg" property itself.

Definition at line 716 of file fdt.c.

                                                  {
        int rc;
 
        /* Read #address-cells, if present */
        if ( ( rc = fdt_u32 ( fdt, offset, "#address-cells",
                              &regs->address_cells ) ) != 0 ) {
                regs->address_cells = FDT_DEFAULT_ADDRESS_CELLS;
        }
 
        /* Read #size-cells, if present */
        if ( ( rc = fdt_u32 ( fdt, offset, "#size-cells",
                              &regs->size_cells ) ) != 0 ) {
                regs->size_cells = FDT_DEFAULT_SIZE_CELLS;
        }
 
        /* Calculate stride */
        regs->stride = ( regs->address_cells + regs->size_cells );
}

References FDT_DEFAULT_ADDRESS_CELLS, FDT_DEFAULT_SIZE_CELLS, fdt_u32(), offset, rc, and regs.

Referenced by fdt_parent_reg_cells(), and fdtmem_update_node().

fdt_parent_reg_cells()

int fdt_parent_reg_cells	(	struct fdt *	fdt,
		unsigned int	offset,
		struct fdt_reg_cells *	regs )

Get parent region cell size specification.

Parameters

fdt	Device tree
offset	Starting node offset
regs	Region cell size specification to fill in

Return values

rc	Return status code

Definition at line 744 of file fdt.c.

                                                        {
        unsigned int parent;
        int rc;
 
        /* Get parent node */
        if ( ( rc = fdt_parent ( fdt, offset, &parent ) ) != 0 )
                return rc;
 
        /* Read #address-cells and #size-cells, if present */
        fdt_reg_cells ( fdt, parent, regs );
 
        return 0;
}

References fdt_parent(), fdt_reg_cells(), offset, rc, and regs.

Referenced by dt_ioremap(), and fdt_reg().

fdt_reg_count()

int fdt_reg_count	(	struct fdt *	fdt,
		unsigned int	offset,
		struct fdt_reg_cells *	regs )

Get number of regions.

Parameters

fdt	Device tree
offset	Starting node offset
regs	Region cell size specification

Return values

count

Number of regions, or negative error

Definition at line 767 of file fdt.c.

                                                 {
        struct fdt_descriptor desc;
        const uint32_t *cell;
        unsigned int count;
        int rc;
 
        /* Find property */
        if ( ( rc = fdt_property ( fdt, offset, "reg", &desc ) ) != 0 )
                return rc;
 
        /* Determine number of regions */
        count = ( desc.len / ( regs->stride * sizeof ( *cell ) ) );
        return count;
}

References count, desc, fdt_property(), offset, rc, and regs.

Referenced by fdtmem_update_node().

fdt_reg_address()

int fdt_reg_address	(	struct fdt *	fdt,
		unsigned int	offset,
		struct fdt_reg_cells *	regs,
		unsigned int	index,
		uint64_t *	address )

Get region address.

Parameters

fdt	Device tree
offset	Starting node offset
regs	Region cell size specification
index	Region index
address	Region starting address to fill in

Return values

rc	Return status code

Definition at line 793 of file fdt.c.

                                          {
        unsigned int cell = ( index * regs->stride );
        int rc;
 
        /* Read relevant portion of region array */
        if ( ( rc = fdt_cells ( fdt, offset, "reg", cell, regs->address_cells,
                                address ) ) != 0 ) {
                return rc;
        }
 
        return 0;
}

References address, fdt_cells(), index, offset, rc, and regs.

Referenced by dt_ioremap(), fdt_reg(), and fdtmem_update_node().

fdt_reg_size()

int fdt_reg_size	(	struct fdt *	fdt,
		unsigned int	offset,
		struct fdt_reg_cells *	regs,
		unsigned int	index,
		uint64_t *	size )

Get region size.

Parameters

fdt	Device tree
offset	Starting node offset
regs	Region cell size specification
index	Region index
size	Region size to fill in

Return values

rc	Return status code

Definition at line 818 of file fdt.c.

                                    {
        unsigned int cell = ( ( index * regs->stride ) + regs->address_cells );
        int rc;
 
        /* Read relevant portion of region array */
        if ( ( rc = fdt_cells ( fdt, offset, "reg", cell, regs->size_cells,
                                size ) ) != 0 ) {
                return rc;
        }
 
        return 0;
}

References fdt_cells(), index, offset, rc, regs, and size.

Referenced by dt_ioremap(), and fdtmem_update_node().

fdt_reg()

int fdt_reg	(	struct fdt *	fdt,
		unsigned int	offset,
		uint64_t *	region )

Get unsized single-entry region address.

Parameters

fdt	Device tree
offset	Starting node offset
address	Region address to fill in

Return values

rc	Return status code

Many region types (e.g. I2C bus addresses) can only ever contain a single region with no size cells specified.

Definition at line 844 of file fdt.c.

                                                                       {
        struct fdt_reg_cells regs;
        int rc;
 
        /* Get parent region cell size specification */
        if ( ( rc = fdt_parent_reg_cells ( fdt, offset, &regs ) ) != 0 )
                return rc;
 
        /* Get first region address */
        if ( ( rc = fdt_reg_address ( fdt, offset, &regs, 0, region ) ) != 0 )
                return rc;
 
        return 0;
}

References fdt_parent_reg_cells(), fdt_reg_address(), offset, rc, and regs.

Referenced by dwgpio_probe().

fdt_mac()

int fdt_mac	(	struct fdt *	fdt,
		unsigned int	offset,
		struct net_device *	netdev )

Get MAC address from property.

Parameters

fdt	Device tree
offset	Starting node offset
netdev	Network device

Return values

rc	Return status code

Definition at line 867 of file fdt.c.

                                          {
        struct fdt_descriptor desc;
        size_t len;
        int rc;
 
        /* Find applicable MAC address property */
        if ( ( ( rc = fdt_property ( fdt, offset, "mac-address",
                                     &desc ) ) != 0 ) &&
             ( ( rc = fdt_property ( fdt, offset, "local-mac-address",
                                     &desc ) ) != 0 ) ) {
                return rc;
        }
 
        /* Check length */
        len = netdev->ll_protocol->hw_addr_len;
        if ( len != desc.len ) {
                DBGC ( fdt, "FDT malformed MAC address \"%s\":\n",
                       desc.name );
                DBGC_HDA ( fdt, 0, desc.data, desc.len );
                return -ERANGE;
        }
 
        /* Fill in MAC address */
        memcpy ( netdev->hw_addr, desc.data, len );
 
        return 0;
}

References DBGC, DBGC_HDA, desc, ERANGE, fdt_property(), len, memcpy(), netdev, offset, and rc.

Referenced by cgem_probe(), dwmac_probe(), and smscusb_fdt_fetch_mac().

fdt_parse()

int fdt_parse	(	struct fdt *	fdt,
		struct fdt_header *	hdr,
		size_t	max_len )

Parse device tree.

Parameters

fdt	Device tree
hdr	Device tree header
max_len	Maximum device tree length

Return values

rc	Return status code

Definition at line 904 of file fdt.c.

                                                                          {
        const uint8_t *nul;
        unsigned int chosen;
        size_t end;
 
        /* Sanity check */
        if ( sizeof ( *hdr ) > max_len ) {
                DBGC ( fdt, "FDT length %#zx too short for header\n",
                       max_len );
                goto err;
        }
 
        /* Record device tree location */
        fdt->hdr = hdr;
        fdt->len = be32_to_cpu ( hdr->totalsize );
        fdt->used = sizeof ( *hdr );
        if ( fdt->len > max_len ) {
                DBGC ( fdt, "FDT has invalid length %#zx / %#zx\n",
                       fdt->len, max_len );
                goto err;
        }
        DBGC ( fdt, "FDT version %d at %p+%#04zx (phys %#08lx)\n",
               be32_to_cpu ( hdr->version ), fdt->hdr, fdt->len,
               virt_to_phys ( hdr ) );
 
        /* Check signature */
        if ( hdr->magic != cpu_to_be32 ( FDT_MAGIC ) ) {
                DBGC ( fdt, "FDT has invalid magic value %#08x\n",
                       be32_to_cpu ( hdr->magic ) );
                goto err;
        }
 
        /* Check version */
        if ( hdr->last_comp_version != cpu_to_be32 ( FDT_VERSION ) ) {
                DBGC ( fdt, "FDT unsupported version %d\n",
                       be32_to_cpu ( hdr->last_comp_version ) );
                goto err;
        }
 
        /* Record structure block location */
        fdt->structure = be32_to_cpu ( hdr->off_dt_struct );
        fdt->structure_len = be32_to_cpu ( hdr->size_dt_struct );
        DBGC ( fdt, "FDT structure block at +[%#04x,%#04zx)\n",
               fdt->structure, ( fdt->structure + fdt->structure_len ) );
        if ( ( fdt->structure > fdt->len ) ||
             ( fdt->structure_len > ( fdt->len - fdt->structure ) ) ) {
                DBGC ( fdt, "FDT structure block exceeds table\n" );
                goto err;
        }
        if ( ( fdt->structure | fdt->structure_len ) &
             ( FDT_STRUCTURE_ALIGN - 1 ) ) {
                DBGC ( fdt, "FDT structure block is misaligned\n" );
                goto err;
        }
        end = ( fdt->structure + fdt->structure_len );
        if ( fdt->used < end )
                fdt->used = end;
 
        /* Record strings block location */
        fdt->strings = be32_to_cpu ( hdr->off_dt_strings );
        fdt->strings_len = be32_to_cpu ( hdr->size_dt_strings );
        DBGC ( fdt, "FDT strings block at +[%#04x,%#04zx)\n",
               fdt->strings, ( fdt->strings + fdt->strings_len ) );
        if ( ( fdt->strings > fdt->len ) ||
             ( fdt->strings_len > ( fdt->len - fdt->strings ) ) ) {
                DBGC ( fdt, "FDT strings block exceeds table\n" );
                goto err;
        }
        end = ( fdt->strings + fdt->strings_len );
        if ( fdt->used < end )
                fdt->used = end;
 
        /* Shrink strings block to ensure NUL termination safety */
        nul = ( fdt->raw + fdt->strings + fdt->strings_len );
        for ( ; fdt->strings_len ; fdt->strings_len-- ) {
                if ( *(--nul) == '\0' )
                        break;
        }
        if ( fdt->strings_len != be32_to_cpu ( hdr->size_dt_strings ) ) {
                DBGC ( fdt, "FDT strings block shrunk to +[%#04x,%#04zx)\n",
                       fdt->strings, ( fdt->strings + fdt->strings_len ) );
        }
 
        /* Record memory reservation block location */
        fdt->reservations = be32_to_cpu ( hdr->off_mem_rsvmap );
        DBGC ( fdt, "FDT memory reservations at +[%#04x,...)\n",
               fdt->reservations );
        if ( fdt->used <= fdt->reservations ) {
                /* No size field exists: assume whole table is used */
                fdt->used = fdt->len;
        }
 
        /* Identify free space (if any) */
        if ( fdt->used < fdt->len ) {
                DBGC ( fdt, "FDT free space at +[%#04zx,%#04zx)\n",
                       fdt->used, fdt->len );
        }
 
        /* Print model name and boot arguments (for debugging) */
        if ( DBG_LOG ) {
                DBGC ( fdt, "FDT model is \"%s\"\n",
                       fdt_string ( fdt, 0, "model" ) );
                if ( fdt_child ( fdt, 0, "chosen", &chosen ) == 0 ) {
                        DBGC ( fdt, "FDT boot arguments \"%s\"\n",
                               fdt_string ( fdt, chosen, "bootargs" ) );
                }
        }
 
        return 0;
 
 err:
        DBGC_HDA ( fdt, 0, hdr, sizeof ( *hdr ) );
        memset ( fdt, 0, sizeof ( *fdt ) );
        return -EINVAL;
}

References be32_to_cpu, cpu_to_be32, DBG_LOG, DBGC, DBGC_HDA, EINVAL, end, fdt_child(), FDT_MAGIC, fdt_string(), FDT_STRUCTURE_ALIGN, FDT_VERSION, fdt::hdr, hdr, fdt::len, memset(), fdt::raw, fdt::reservations, fdt::strings, fdt::strings_len, fdt::structure, fdt::structure_len, and fdt::used.

Referenced by efi_fdt_init(), fdt_parse_image(), fdt_test_exec(), fdtmem_register(), and fdtmem_relocate().

fdt_parse_image()

int fdt_parse_image ( struct fdt * fdt, struct image * image )

static

Parse device tree image.

Parameters

fdt	Device tree
image	Image

Return values

rc	Return status code

Definition at line 1027 of file fdt.c.

                                                                    {
        int rc;
 
        /* Parse image */
        if ( ( rc = fdt_parse ( fdt, image->rwdata, image->len ) ) != 0 ) {
                DBGC ( fdt, "FDT image \"%s\" is invalid: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }
 
        DBGC ( fdt, "FDT image is \"%s\"\n", image->name );
        return 0;
}

References DBGC, fdt_parse(), image::len, image::name, rc, image::rwdata, and strerror().

Referenced by fdt_create().

fdt_insert()

int fdt_insert ( struct fdt * fdt, unsigned int offset, size_t len )

static

Insert empty space.

Parameters

fdt	Device tree
offset	Offset at which to insert space
len	Length to insert (must be a multiple of FDT_MAX_ALIGN)

Return values

rc	Return status code

Definition at line 1049 of file fdt.c.

                                                                           {
        size_t free;
        size_t new;
        int rc;
 
        /* Sanity checks */
        assert ( offset <= fdt->used );
        assert ( fdt->used <= fdt->len );
        assert ( ( len % FDT_MAX_ALIGN ) == 0 );
 
        /* Reallocate tree if necessary */
        free = ( fdt->len - fdt->used );
        if ( free < len ) {
                if ( ! fdt->realloc ) {
                        DBGC ( fdt, "FDT is not reallocatable\n" );
                        return -ENOTSUP;
                }
                new = ( fdt->len + ( len - free ) + FDT_INSERT_PAD );
                if ( ( rc = fdt->realloc ( fdt, new ) ) != 0 )
                        return rc;
        }
        assert ( ( fdt->used + len ) <= fdt->len );
 
        /* Insert empty space */
        memmove ( ( fdt->raw + offset + len ), ( fdt->raw + offset ),
                  ( fdt->used - offset ) );
        memset ( ( fdt->raw + offset ), 0, len );
        fdt->used += len;
 
        /* Update offsets
         *
         * We assume that we never need to legitimately insert data at
         * the start of a block, and therefore can unambiguously
         * determine which block offsets need to be updated.
         *
         * It is the caller's responsibility to update the length (and
         * contents) of the block into which it has inserted space.
         */
        if ( fdt->structure >= offset ) {
                fdt->structure += len;
                fdt->hdr->off_dt_struct = cpu_to_be32 ( fdt->structure );
                DBGC ( fdt, "FDT structure block now at +[%#04x,%#04zx)\n",
                       fdt->structure,
                       ( fdt->structure + fdt->structure_len ) );
        }
        if ( fdt->strings >= offset ) {
                fdt->strings += len;
                fdt->hdr->off_dt_strings = cpu_to_be32 ( fdt->strings );
                DBGC ( fdt, "FDT strings block now at +[%#04x,%#04zx)\n",
                       fdt->strings, ( fdt->strings + fdt->strings_len ) );
        }
        if ( fdt->reservations >= offset ) {
                fdt->reservations += len;
                fdt->hdr->off_mem_rsvmap = cpu_to_be32 ( fdt->reservations );
                DBGC ( fdt, "FDT memory reservations now at +[%#04x,...)\n",
                       fdt->reservations );
        }
 
        return 0;
}

References assert, cpu_to_be32, DBGC, ENOTSUP, FDT_INSERT_PAD, FDT_MAX_ALIGN, free, fdt::hdr, fdt::len, len, memmove(), memset(), fdt_header::off_dt_strings, fdt_header::off_dt_struct, fdt_header::off_mem_rsvmap, offset, fdt::raw, rc, fdt::realloc, fdt::reservations, fdt::strings, fdt::strings_len, fdt::structure, fdt::structure_len, and fdt::used.

Referenced by fdt_insert_nop(), and fdt_insert_string().

fdt_nop()

void fdt_nop ( struct fdt * fdt, unsigned int offset, size_t len )

static

Fill space in structure block with FDT_NOP.

Parameters

fdt	Device tree
offset	Starting offset
len	Length (must be a multiple of FDT_STRUCTURE_ALIGN)

Definition at line 1117 of file fdt.c.

                                                                         {
        fdt_token_t *token;
        unsigned int count;
 
        /* Sanity check */
        assert ( ( len % FDT_STRUCTURE_ALIGN ) == 0 );
 
        /* Fill with FDT_NOP */
        token = ( fdt->raw + fdt->structure + offset );
        count = ( len / sizeof ( *token ) );
        while ( count-- )
                *(token++) = cpu_to_be32 ( FDT_NOP );
}

References assert, count, cpu_to_be32, FDT_NOP, FDT_STRUCTURE_ALIGN, len, offset, fdt::raw, fdt::structure, and token.

Referenced by fdt_insert_nop(), and fdt_set().

fdt_insert_nop()

int fdt_insert_nop ( struct fdt * fdt, unsigned int offset, size_t len )

static

Insert FDT_NOP padded space in structure block.

Parameters

fdt	Device tree
offset	Offset at which to insert space
len	Minimal length to insert

Return values

rc	Return status code

Definition at line 1139 of file fdt.c.

                                         {
        int rc;
 
        /* Sanity check */
        assert ( ( offset % FDT_STRUCTURE_ALIGN ) == 0 );
 
        /* Round up inserted length to maximal alignment */
        len = ( ( len + FDT_MAX_ALIGN - 1 ) & ~( FDT_MAX_ALIGN - 1 ) );
 
        /* Insert empty space in structure block */
        if ( ( rc = fdt_insert ( fdt, ( fdt->structure + offset ),
                                 len ) ) != 0 )
                return rc;
 
        /* Fill with NOPs */
        fdt_nop ( fdt, offset, len );
 
        /* Update structure block size */
        fdt->structure_len += len;
        fdt->hdr->size_dt_struct = cpu_to_be32 ( fdt->structure_len );
        DBGC ( fdt, "FDT structure block now at +[%#04x,%#04zx)\n",
               fdt->structure, ( fdt->structure + fdt->structure_len ) );
 
        return 0;
}

References assert, cpu_to_be32, DBGC, fdt_insert(), FDT_MAX_ALIGN, fdt_nop(), FDT_STRUCTURE_ALIGN, fdt::hdr, len, offset, rc, fdt_header::size_dt_struct, fdt::structure, and fdt::structure_len.

Referenced by fdt_ensure_child(), and fdt_set().

fdt_insert_string()

int fdt_insert_string ( struct fdt * fdt, const char * string, unsigned int * offset )

static

Insert string in strings block.

Parameters

fdt	Device tree
string	String
offset	String offset to fill in

Return values

rc	Return status code

Definition at line 1174 of file fdt.c.

                                                      {
        size_t len = ( strlen ( string ) + 1 /* NUL */ );
        int rc;
 
        /* Round up inserted length to maximal alignment */
        len = ( ( len + FDT_MAX_ALIGN - 1 ) & ~( FDT_MAX_ALIGN - 1 ) );
 
        /* Insert space at end of strings block */
        if ( ( rc = fdt_insert ( fdt, ( fdt->strings + fdt->strings_len ),
                                 len ) ) != 0 )
                return rc;
 
        /* Append string to strings block */
        *offset = fdt->strings_len;
        strcpy ( ( fdt->raw + fdt->strings + *offset ), string );
 
        /* Update strings block size */
        fdt->strings_len += len;
        fdt->hdr->size_dt_strings = cpu_to_be32 ( fdt->strings_len );
        DBGC ( fdt, "FDT strings block now at +[%#04x,%#04zx)\n",
                       fdt->strings, ( fdt->strings + fdt->strings_len ) );
 
        return 0;
}

References cpu_to_be32, DBGC, fdt_insert(), FDT_MAX_ALIGN, fdt::hdr, len, offset, fdt::raw, rc, fdt_header::size_dt_strings, strcpy(), fdt::strings, fdt::strings_len, and strlen().

Referenced by fdt_set().

fdt_ensure_child()

int fdt_ensure_child ( struct fdt * fdt, unsigned int offset, const char * name, unsigned int * child )

static

Ensure child node exists.

Parameters

fdt	Device tree
offset	Starting node offset
name	New node name
child	Child node offset to fill in

Return values

rc	Return status code

Definition at line 1209 of file fdt.c.

                                                                      {
        size_t name_len = ( strlen ( name ) + 1 /* NUL */ );
        fdt_token_t *token;
        size_t len;
        int rc;
 
        /* Find existing child node, if any */
        if ( ( rc = fdt_child ( fdt, offset, name, child ) ) == 0 )
                return 0;
 
        /* Find end of parent node */
        if ( ( rc = fdt_end ( fdt, offset, child ) ) != 0 )
                return rc;
 
        /* Insert space for child node (with maximal alignment) */
        len = ( sizeof ( fdt_token_t ) /* BEGIN_NODE */ + name_len +
                sizeof ( fdt_token_t ) /* END_NODE */ );
        if ( ( rc = fdt_insert_nop ( fdt, *child, len ) ) != 0 )
                return rc;
 
        /* Construct node */
        token = ( fdt->raw + fdt->structure + *child );
        *(token++) = cpu_to_be32 ( FDT_BEGIN_NODE );
        memcpy ( token, name, name_len );
        name_len = ( ( name_len + FDT_STRUCTURE_ALIGN - 1 ) &
                     ~( FDT_STRUCTURE_ALIGN - 1 ) );
        token = ( ( ( void * ) token ) + name_len );
        *(token++) = cpu_to_be32 ( FDT_END_NODE );
        DBGC2 ( fdt, "FDT +%#04x created child \"%s\" at +%#04x\n",
                offset, name, *child );
 
        return 0;
}

References cpu_to_be32, DBGC2, FDT_BEGIN_NODE, fdt_child(), fdt_end(), FDT_END_NODE, fdt_insert_nop(), FDT_STRUCTURE_ALIGN, len, memcpy(), name, offset, fdt::raw, rc, strlen(), fdt::structure, and token.

Referenced by fdt_bootargs().

fdt_set()

int fdt_set ( struct fdt * fdt, unsigned int offset, const char * name, const void * data, size_t len )

static

Set property value.

Parameters

fdt	Device tree
offset	Starting node offset
name	Property name
data	Property data, or NULL to delete property
len	Length of property data

Return values

rc	Return status code

Definition at line 1254 of file fdt.c.

                                                    {
        struct fdt_descriptor desc;
        struct {
                fdt_token_t token;
                struct fdt_prop prop;
                uint8_t data[0];
        } __attribute__ (( packed )) *hdr;
        unsigned int string;
        size_t erase;
        size_t insert;
        int rc;
 
        /* Find and reuse existing property, if any */
        if ( ( rc = fdt_property ( fdt, offset, name, &desc ) ) == 0 ) {
 
                /* Reuse existing name */
                hdr = ( fdt->raw + fdt->structure + desc.offset );
                string = be32_to_cpu ( hdr->prop.name_off );
 
                /* Erase existing property */
                erase = ( sizeof ( *hdr ) + desc.len );
                erase = ( ( erase + FDT_STRUCTURE_ALIGN - 1 ) &
                          ~( FDT_STRUCTURE_ALIGN - 1 ) );
                fdt_nop ( fdt, desc.offset, erase );
                DBGC2 ( fdt, "FDT +%#04x erased property \"%s\"\n",
                        offset, name );
 
                /* Calculate insertion position and length */
                insert = ( ( desc.len < len ) ? ( len - desc.len ) : 0 );
 
        } else {
 
                /* Create name */
                if ( ( rc = fdt_insert_string ( fdt, name, &string ) ) != 0 )
                        return rc;
 
                /* Enter node */
                if ( ( rc = fdt_enter ( fdt, offset, &desc ) ) != 0 )
                        return rc;
                assert ( desc.depth > 0 );
                desc.offset = desc.next;
 
                /* Calculate insertion length */
                insert = ( sizeof ( *hdr ) + len );
        }
 
        /* Leave property erased if applicable */
        if ( ! data )
                return 0;
 
        /* Insert space */
        if ( ( rc = fdt_insert_nop ( fdt, desc.offset, insert ) ) != 0 )
                return rc;
 
        /* Construct property */
        hdr = ( fdt->raw + fdt->structure + desc.offset );
        hdr->token = cpu_to_be32 ( FDT_PROP );
        hdr->prop.len = cpu_to_be32 ( len );
        hdr->prop.name_off = cpu_to_be32 ( string );
        memset ( hdr->data, 0, ( ( len + FDT_STRUCTURE_ALIGN - 1 ) &
                                 ~( FDT_STRUCTURE_ALIGN - 1 ) ) );
        memcpy ( hdr->data, data, len );
        DBGC2 ( fdt, "FDT +%#04x created property \"%s\"\n", offset, name );
        DBGC2_HDA ( fdt, 0, hdr->data, len );
 
        return 0;
}

References __attribute__, assert, be32_to_cpu, cpu_to_be32, data, DBGC2, DBGC2_HDA, desc, erase(), fdt_enter(), fdt_insert_nop(), fdt_insert_string(), fdt_nop(), FDT_PROP, fdt_property(), FDT_STRUCTURE_ALIGN, hdr, len, memcpy(), memset(), name, offset, fdt::raw, rc, string, fdt::structure, and token.

Referenced by fdt_bootargs().

fdt_urealloc()

int fdt_urealloc ( struct fdt * fdt, size_t len )

static

Reallocate device tree via urealloc()

Parameters

fdt	Device tree
len	New total length

Return values

rc	Return status code

Definition at line 1330 of file fdt.c.

                                                        {
        void *new;
 
        /* Sanity check */
        assert ( len >= fdt->used );
 
        /* Attempt reallocation */
        new = urealloc ( fdt->raw, len );
        if ( ! new ) {
                DBGC ( fdt, "FDT could not reallocate from +%#04zx to "
                       "+%#04zx\n", fdt->len, len );
                return -ENOMEM;
        }
        DBGC ( fdt, "FDT reallocated from +%#04zx to +%#04zx\n",
               fdt->len, len );
 
        /* Update device tree */
        fdt->raw = new;
        fdt->len = len;
        fdt->hdr->totalsize = cpu_to_be32 ( len );
 
        return 0;
}

References assert, cpu_to_be32, DBGC, ENOMEM, fdt::hdr, fdt::len, len, fdt::raw, fdt_header::totalsize, urealloc(), and fdt::used.

Referenced by fdt_create().

fdt_bootargs()

int fdt_bootargs ( struct fdt * fdt, const char * cmdline, physaddr_t initrd, size_t initrd_len )

static

Populate device tree with boot arguments.

Parameters

fdt	Device tree
cmdline	Command line, or NULL
initrd	Initial ramdisk address (or 0 for no initrd)
initrd_len	Initial ramdisk length (or 0 for no initrd)

Return values

rc	Return status code

Definition at line 1363 of file fdt.c.

                                                                 {
        unsigned int chosen;
        physaddr_t addr;
        const void *data;
        size_t len;
        int rc;
 
        /* Ensure "chosen" node exists */
        if ( ( rc = fdt_ensure_child ( fdt, 0, "chosen", &chosen ) ) != 0 )
                return rc;
 
        /* Set or clear "bootargs" property */
        len = ( cmdline ? ( strlen ( cmdline ) + 1 /* NUL */ ) : 0 );
        if ( ( rc = fdt_set ( fdt, chosen, "bootargs", cmdline, len ) ) != 0 )
                return rc;
 
        /* Set or clear initrd properties */
        data = ( initrd_len ? &addr : NULL );
        len = ( initrd_len ? sizeof ( addr ) : 0 );
        addr = initrd;
        addr = ( ( sizeof ( addr ) == sizeof ( uint64_t ) ) ?
                 cpu_to_be64 ( addr ) : cpu_to_be32 ( addr ) );
        if ( ( rc = fdt_set ( fdt, chosen, "linux,initrd-start", data,
                              len ) ) != 0 )
                return rc;
        addr = ( initrd + initrd_len );
        addr = ( ( sizeof ( addr ) == sizeof ( uint64_t ) ) ?
                 cpu_to_be64 ( addr ) : cpu_to_be32 ( addr ) );
        if ( ( rc = fdt_set ( fdt, chosen, "linux,initrd-end", data,
                              len ) ) != 0 )
                return rc;
 
        return 0;
}

References addr, cmdline, cpu_to_be32, cpu_to_be64, data, fdt_ensure_child(), fdt_set(), initrd_len, len, NULL, rc, and strlen().

Referenced by fdt_create().

fdt_create()

int fdt_create	(	struct fdt_header **	hdr,
		const char *	cmdline,
		physaddr_t	initrd,
		size_t	initrd_len )

Create device tree.

Parameters

hdr	Device tree header to fill in (may be set to NULL)
cmdline	Command line, or NULL
initrd	Initial ramdisk address (or 0 for no initrd)
initrd_len	Initial ramdisk length (or 0 for no initrd)

Return values

rc	Return status code

Definition at line 1408 of file fdt.c.

                                                        {
        struct image *image;
        struct fdt fdt;
        void *copy;
        int rc;
 
        /* Use system FDT as the base by default */
        memcpy ( &fdt, &sysfdt, sizeof ( fdt ) );
 
        /* If an FDT image exists, use this instead */
        image = find_image_tag ( &fdt_image );
        if ( image && ( ( rc = fdt_parse_image ( &fdt, image ) ) != 0 ) )
                goto err_image;
 
        /* Exit successfully if we have no base FDT */
        if ( ! fdt.len ) {
                DBGC ( &fdt, "FDT has no base tree\n" );
                goto no_fdt;
        }
 
        /* Create modifiable copy */
        copy = umalloc ( fdt.len );
        if ( ! copy ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        memcpy ( copy, fdt.raw, fdt.len );
        fdt.raw = copy;
        fdt.realloc = fdt_urealloc;
 
        /* Populate boot arguments */
        if ( ( rc = fdt_bootargs ( &fdt, cmdline, initrd, initrd_len ) ) != 0 )
                goto err_bootargs;
 
 no_fdt:
        *hdr = fdt.raw;
        return 0;
 
 err_bootargs:
        ufree ( fdt.raw );
 err_alloc:
 err_image:
        return rc;
}

References cmdline, DBGC, ENOMEM, fdt_bootargs(), fdt_parse_image(), fdt_urealloc(), find_image_tag(), hdr, initrd_len, fdt::len, memcpy(), fdt::raw, rc, fdt::realloc, sysfdt, ufree(), and umalloc().

Referenced by efi_fdt_install(), fdt_test_exec(), and lkrn_exec().

fdt_remove()

void fdt_remove

(

struct fdt_header *

hdr

)

Remove device tree.

Parameters

hdr	Device tree header, or NULL

Definition at line 1459 of file fdt.c.

                                           {
 
        /* Free modifiable copy */
        ufree ( hdr );
}

References hdr, and ufree().

Referenced by efi_fdt_install(), efi_fdt_uninstall(), fdt_test_exec(), and lkrn_exec().

REQUIRING_SYMBOL()

REQUIRING_SYMBOL

(

fdt_describe

)

References fdt_describe().

REQUIRE_OBJECT()

REQUIRE_OBJECT

(

config_fdt

)

Variable Documentation

sysfdt

struct fdt sysfdt

The system flattened device tree (if present)

Definition at line 45 of file fdt.c.

Referenced by cgem_probe(), dt_find_driver(), dt_ioremap(), dt_probe_children(), dt_probe_node(), dwgpio_probe(), dwmac_probe(), dwuart_probe(), efi_fdt_init(), fdt_create(), fdtcon_default(), fdtmem_describe_region(), fdtmem_register(), and smscusb_fdt_fetch_mac().

__image_tag

struct image_tag fdt_image __image_tag

Initial value:

= {
        .name = "FDT",
}

The downloaded flattened device tree tag.

Definition at line 48 of file fdt.c.

                                         {
        .name = "FDT",
};