fdt.h File Reference

Flattened Device Tree. More...

#include <stdint.h>
#include <ipxe/image.h>

Go to the source code of this file.

Data Structures
struct	fdt_header
	Device tree header. More...
struct	fdt_prop
	Property fragment. More...
struct	fdt_reservation
	A memory reservation. More...
struct	fdt
	A device tree. More...
struct	fdt_descriptor
	A device tree token descriptor. More...
struct	fdt_reg_cells
	A device tree region cell size specification. More...

Macros
#define	FDT_MAGIC   0xd00dfeed
	Magic signature.
#define	FDT_VERSION   16
	Expected device tree version.
#define	FDT_BEGIN_NODE   0x00000001
	Begin node token.
#define	FDT_END_NODE   0x00000002
	End node token.
#define	FDT_PROP   0x00000003
	Property token.
#define	FDT_NOP   0x00000004
	NOP token.
#define	FDT_END   0x00000009
	End of structure block.
#define	FDT_STRUCTURE_ALIGN   ( sizeof ( fdt_token_t ) )
	Alignment of structure block.
#define	FDT_MAX_ALIGN   8
	Maximum alignment of any block.
#define	FDT_DEFAULT_ADDRESS_CELLS   2
	Default number of address cells, if not specified.
#define	FDT_DEFAULT_SIZE_CELLS   1
	Default number of size cells, if not specified.
#define	for_each_fdt_reservation(rsv, fdt)
	Iterate over memory reservations.

Typedefs
typedef uint32_t	fdt_token_t
	Device tree token.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static const struct fdt_reservation *	fdt_reservations (struct fdt *fdt)
	Get memory reservations.
int	fdt_describe (struct fdt *fdt, unsigned int offset, struct fdt_descriptor *desc)
	Describe device tree token.
int	fdt_parent (struct fdt *fdt, unsigned int offset, unsigned int *parent)
	Find parent 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.
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.
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.

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

Detailed Description

Flattened Device Tree.

Definition in file fdt.h.

Macro Definition Documentation

FDT_MAGIC

#define FDT_MAGIC   0xd00dfeed

Magic signature.

Definition at line 43 of file fdt.h.

Referenced by fdt_parse().

FDT_VERSION

#define FDT_VERSION   16

Expected device tree version.

Definition at line 46 of file fdt.h.

Referenced by fdt_parse().

FDT_BEGIN_NODE

#define FDT_BEGIN_NODE   0x00000001

Begin node token.

Definition at line 52 of file fdt.h.

Referenced by fdt_describe(), and fdt_ensure_child().

FDT_END_NODE

#define FDT_END_NODE   0x00000002

End node token.

Definition at line 55 of file fdt.h.

Referenced by fdt_describe(), and fdt_ensure_child().

FDT_PROP

#define FDT_PROP   0x00000003

Property token.

Definition at line 58 of file fdt.h.

Referenced by fdt_describe(), and fdt_set().

FDT_NOP

#define FDT_NOP   0x00000004

NOP token.

Definition at line 69 of file fdt.h.

Referenced by fdt_describe(), and fdt_nop().

FDT_END

#define FDT_END   0x00000009

End of structure block.

Definition at line 72 of file fdt.h.

FDT_STRUCTURE_ALIGN

#define FDT_STRUCTURE_ALIGN   ( sizeof ( fdt_token_t ) )

Alignment of structure block.

Definition at line 75 of file fdt.h.

Referenced by fdt_describe(), fdt_ensure_child(), fdt_insert_nop(), fdt_nop(), fdt_parse(), and fdt_set().

FDT_MAX_ALIGN

#define FDT_MAX_ALIGN   8

Maximum alignment of any block.

Definition at line 78 of file fdt.h.

Referenced by fdt_insert(), fdt_insert_nop(), fdt_insert_string(), and fdtmem_len().

FDT_DEFAULT_ADDRESS_CELLS

#define FDT_DEFAULT_ADDRESS_CELLS   2

Default number of address cells, if not specified.

Definition at line 147 of file fdt.h.

Referenced by fdt_reg_cells().

FDT_DEFAULT_SIZE_CELLS

#define FDT_DEFAULT_SIZE_CELLS   1

Default number of size cells, if not specified.

Definition at line 150 of file fdt.h.

Referenced by fdt_reg_cells().

for_each_fdt_reservation

#define for_each_fdt_reservation	(		rsv,
			fdt )

Value:

        for ( rsv = fdt_reservations ( (fdt) ) ;             \
              ( (rsv)->start || (rsv)->size ) ; rsv++ )

Iterate over memory reservations.

Definition at line 168 of file fdt.h.

#define for_each_fdt_reservation( rsv, fdt )                    \
        for ( rsv = fdt_reservations ( (fdt) ) ;                \
              ( (rsv)->start || (rsv)->size ) ; rsv++ )

Referenced by fdtmem_update_tree().

Typedef Documentation

fdt_token_t

typedef uint32_t fdt_token_t

Device tree token.

Definition at line 49 of file fdt.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

fdt_reservations()

const struct fdt_reservation * fdt_reservations ( struct fdt * fdt )

inlinestatic

Get memory reservations.

Parameters

fdt	Device tree

Return values

rsv	Memory reservations

Definition at line 162 of file fdt.h.

                                     {
 
        return ( fdt->raw + fdt->reservations );
}

References fdt::raw, and fdt::reservations.

fdt_describe()

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

extern

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_parent()

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

extern

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_path()

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

extern

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 )

extern

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_strings()

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

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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 )

extern

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_create()

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

extern

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 )

extern

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().

Variable Documentation

__image_tag

struct image_tag fdt_image __image_tag

extern

The downloaded flattened device tree tag.

The downloaded flattened device tree tag.

Currently-executing image.

The downloaded flattened device tree tag.

Definition at line 48 of file fdt.c.

                                         {
        .name = "FDT",
};

sysfdt

struct fdt sysfdt

extern

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().