fdt.h File Reference

Flattened Device Tree. More...

#include <stdint.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
	A device tree. More...

Macros
#define	FDT_MAGIC   0xd00dfeed
	Magic signature. More...
#define	FDT_VERSION   16
	Expected device tree version. More...
#define	FDT_BEGIN_NODE   0x00000001
	Begin node token. More...
#define	FDT_END_NODE   0x00000002
	End node token. More...
#define	FDT_PROP   0x00000003
	Property token. More...
#define	FDT_NOP   0x00000004
	NOP token. More...
#define	FDT_END   0x00000009
	End of structure block. More...
#define	FDT_STRUCTURE_ALIGN   ( sizeof ( fdt_token_t ) )
	Alignment of structure block. More...

Typedefs
typedef uint32_t	fdt_token_t
	Device tree token. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
struct fdt_header	__attribute__ ((packed))
int	fdt_path (const char *path, unsigned int *offset)
	Find node by path. More...
int	fdt_alias (const char *name, unsigned int *offset)
	Find node by alias. More...
const char *	fdt_string (unsigned int offset, const char *name)
	Find string property. More...
int	fdt_u64 (unsigned int offset, const char *name, uint64_t *value)
	Find integer property. More...
int	fdt_mac (unsigned int offset, struct net_device *netdev)
	Get MAC address from property. More...
int	register_fdt (const struct fdt_header *hdr)
	Register device tree. More...

Variables
uint32_t	magic
	Magic signature. More...
uint32_t	totalsize
	Total size of device tree. More...
uint32_t	off_dt_struct
	Offset to structure block. More...
uint32_t	off_dt_strings
	Offset to strings block. More...
uint32_t	off_mem_rsvmap
	Offset to memory reservation block. More...
uint32_t	version
	Version of this data structure. More...
uint32_t	last_comp_version
	Lowest version to which this structure is compatible. More...
uint32_t	boot_cpuid_phys
	Physical ID of the boot CPU. More...
uint32_t	size_dt_strings
	Length of string block. More...
uint32_t	size_dt_struct
	Length of structure block. More...
uint32_t	len
	Data length. More...
uint32_t	name_off
	Name offset. More...
struct fdt	__attribute__

Detailed Description

Flattened Device Tree.

Definition in file fdt.h.

Macro Definition Documentation

FDT_MAGIC

#define FDT_MAGIC   0xd00dfeed

Magic signature.

Definition at line 41 of file fdt.h.

FDT_VERSION

#define FDT_VERSION   16

Expected device tree version.

Definition at line 44 of file fdt.h.

FDT_BEGIN_NODE

#define FDT_BEGIN_NODE   0x00000001

Begin node token.

Definition at line 50 of file fdt.h.

FDT_END_NODE

#define FDT_END_NODE   0x00000002

End node token.

Definition at line 53 of file fdt.h.

FDT_PROP

#define FDT_PROP   0x00000003

Property token.

Definition at line 56 of file fdt.h.

FDT_NOP

#define FDT_NOP   0x00000004

NOP token.

Definition at line 67 of file fdt.h.

FDT_END

#define FDT_END   0x00000009

End of structure block.

Definition at line 70 of file fdt.h.

FDT_STRUCTURE_ALIGN

#define FDT_STRUCTURE_ALIGN   ( sizeof ( fdt_token_t ) )

Alignment of structure block.

Definition at line 73 of file fdt.h.

Typedef Documentation

fdt_token_t

typedef uint32_t fdt_token_t

Device tree token.

Definition at line 47 of file fdt.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

__attribute__()

struct fdt_header __attribute__

(

(packed)

)

fdt_path()

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

Find node by path.

Parameters

path	Node path
offset	Offset to fill in

Return values

rc	Return status code

Definition at line 241 of file fdt.c.

                                                        {
        char *tmp = ( ( char * ) path );
        char *del;
        int rc;

        /* Initialise offset */
        *offset = 0;

        /* Traverse tree one path segment at a time */
        while ( *tmp ) {

                /* Skip any leading '/' */
                while ( *tmp == '/' )
                        tmp++;

                /* Find next '/' delimiter and convert to NUL */
                del = strchr ( tmp, '/' );
                if ( del )
                        *del = '\0';

                /* Find child and restore delimiter */
                rc = fdt_child ( *offset, tmp, offset );
                if ( del )
                        *del = '/';
                if ( rc != 0 )
                        return rc;

                /* Move to next path component, if any */
                while ( *tmp && ( *tmp != '/' ) )
                        tmp++;
        }

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

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

Find node by alias.

Parameters

name	Alias name
offset	Offset to fill in

Return values

rc	Return status code

Definition at line 284 of file fdt.c.

                                                         {
        const char *alias;
        int rc;

        /* Locate "/aliases" node */
        if ( ( rc = fdt_child ( 0, "aliases", offset ) ) != 0 )
                return rc;

        /* Locate alias property */
        if ( ( alias = fdt_string ( *offset, name ) ) == NULL )
                return -ENOENT;
        DBGC ( &fdt, "FDT alias \"%s\" is \"%s\"\n", name, alias );

        /* Locate aliased node */
        if ( ( rc = fdt_path ( alias, offset ) ) != 0 )
                return rc;

        return 0;
}

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

Referenced by smscusb_fdt_fetch_mac().

fdt_string()

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

Find string property.

Parameters

offset	Starting node offset
name	Property name

Return values

string

String property, or NULL on error

Definition at line 352 of file fdt.c.

                                                                  {
        struct fdt_descriptor desc;
        int rc;

        /* Find property */
        if ( ( rc = fdt_property ( offset, name, &desc ) ) != 0 )
                return NULL;

        /* Check NUL termination */
        if ( strnlen ( desc.data, desc.len ) == desc.len ) {
                DBGC ( &fdt, "FDT unterminated string property \"%s\"\n",
                       name );
                return NULL;
        }

        return desc.data;
}

References DBGC, desc, fdt_property(), name, NULL, offset, rc, and strnlen().

Referenced by fdt_alias(), and register_fdt().

fdt_u64()

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

Find integer property.

Parameters

offset	Starting node offset
name	Property name
value	Integer value to fill in

Return values

rc	Return status code

Definition at line 378 of file fdt.c.

                                                                       {
        struct fdt_descriptor desc;
        const uint8_t *data;
        size_t remaining;
        int rc;

        /* Clear value */
        *value = 0;

        /* Find property */
        if ( ( rc = fdt_property ( offset, name, &desc ) ) != 0 )
                return rc;

        /* Check range */
        if ( desc.len > sizeof ( *value ) ) {
                DBGC ( &fdt, "FDT oversized integer property \"%s\"\n", name );
                return -ERANGE;
        }

        /* Parse value */
        data = desc.data;
        remaining = desc.len;
        while ( remaining-- ) {
                *value <<= 8;
                *value |= *(data++);
        }

        return 0;
}

References data, DBGC, desc, ERANGE, fdt_property(), name, offset, rc, and value.

fdt_mac()

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

Get MAC address from property.

Parameters

offset	Starting node offset
netdev	Network device

Return values

rc	Return status code

Definition at line 415 of file fdt.c.

                                                               {
        struct fdt_descriptor desc;
        size_t len;
        int rc;

        /* Find applicable MAC address property */
        if ( ( ( rc = fdt_property ( offset, "mac-address", &desc ) ) != 0 ) &&
             ( ( rc = fdt_property ( 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(), net_device::hw_addr, ll_protocol::hw_addr_len, len, net_device::ll_protocol, memcpy(), netdev, offset, and rc.

Referenced by smscusb_fdt_fetch_mac().

register_fdt()

int register_fdt

(

const struct fdt_header *

hdr

)

Register device tree.

Parameters

fdt	Device tree header

Return values

rc	Return status code

Definition at line 448 of file fdt.c.

                                                  {
        const uint8_t *end;

        /* Record device tree location */
        fdt.hdr = hdr;
        fdt.len = be32_to_cpu ( hdr->totalsize );
        DBGC ( &fdt, "FDT version %d at %p+%#04zx\n",
               be32_to_cpu ( hdr->version ), fdt.hdr, fdt.len );

        /* 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;
        }

        /* 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;
        }

        /* Shrink strings block to ensure NUL termination safety */
        end = ( fdt.raw + fdt.strings + fdt.strings_len );
        for ( ; fdt.strings_len ; fdt.strings_len-- ) {
                if ( *(--end) == '\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 ) );
        }

        /* Print model name (for debugging) */
        DBGC ( &fdt, "FDT model is \"%s\"\n", fdt_string ( 0, "model" ) );

        return 0;

 err:
        DBGC_HDA ( &fdt, 0, hdr, sizeof ( *hdr ) );
        fdt.hdr = NULL;
        return -EINVAL;
}

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

Referenced by efi_fdt_init().

Variable Documentation

magic

uint32_t magic

Magic signature.

Definition at line 12 of file fdt.h.

totalsize

uint32_t totalsize

Total size of device tree.

Definition at line 14 of file fdt.h.

off_dt_struct

uint32_t off_dt_struct

Offset to structure block.

Definition at line 16 of file fdt.h.

off_dt_strings

uint32_t off_dt_strings

Offset to strings block.

Definition at line 18 of file fdt.h.

off_mem_rsvmap

uint32_t off_mem_rsvmap

Offset to memory reservation block.

Definition at line 20 of file fdt.h.

version

uint32_t version

Version of this data structure.

Definition at line 22 of file fdt.h.

last_comp_version

uint32_t last_comp_version

Lowest version to which this structure is compatible.

Definition at line 24 of file fdt.h.

boot_cpuid_phys

uint32_t boot_cpuid_phys

Physical ID of the boot CPU.

Definition at line 26 of file fdt.h.

size_dt_strings

uint32_t size_dt_strings

Length of string block.

Definition at line 28 of file fdt.h.

size_dt_struct

uint32_t size_dt_struct

Length of structure block.

Definition at line 30 of file fdt.h.

len

uint32_t len

Data length.

Definition at line 49 of file fdt.h.

name_off

uint32_t name_off

Name offset.

Definition at line 51 of file fdt.h.

Referenced by fdt_traverse().

__attribute__

struct fdt __attribute__