|
|
|
|
@ -18,7 +18,8 @@ |
|
|
|
|
* a struct called fdt_property. That struct causes swig to create a class in |
|
|
|
|
* libfdt.py called fdt_property(), which confuses things. |
|
|
|
|
*/ |
|
|
|
|
static int _fdt_property(void *fdt, const char *name, const char *val, int len) |
|
|
|
|
static int fdt_property_stub(void *fdt, const char *name, const char *val, |
|
|
|
|
int len) |
|
|
|
|
{ |
|
|
|
|
return fdt_property(fdt, name, val, len); |
|
|
|
|
} |
|
|
|
|
@ -54,6 +55,7 @@ import struct |
|
|
|
|
# Pass this as the 'quiet' parameter to return -ENOTFOUND on NOTFOUND errors, |
|
|
|
|
# instead of raising an exception. |
|
|
|
|
QUIET_NOTFOUND = (NOTFOUND,) |
|
|
|
|
QUIET_NOSPACE = (NOSPACE,) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class FdtException(Exception): |
|
|
|
|
@ -119,23 +121,18 @@ def check_err_null(val, quiet=()): |
|
|
|
|
raise FdtException(val) |
|
|
|
|
return val |
|
|
|
|
|
|
|
|
|
class FdtRo(object): |
|
|
|
|
"""Class for a read-only device-tree |
|
|
|
|
|
|
|
|
|
class Fdt: |
|
|
|
|
"""Device tree class, supporting all operations |
|
|
|
|
|
|
|
|
|
The Fdt object is created is created from a device tree binary file, |
|
|
|
|
e.g. with something like: |
|
|
|
|
This is a base class used by FdtRw (read-write access) and FdtSw |
|
|
|
|
(sequential-write access). It implements read-only access to the |
|
|
|
|
device tree. |
|
|
|
|
|
|
|
|
|
fdt = Fdt(open("filename.dtb").read()) |
|
|
|
|
|
|
|
|
|
Operations can then be performed using the methods in this class. Each |
|
|
|
|
method xxx(args...) corresponds to a libfdt function fdt_xxx(fdt, args...). |
|
|
|
|
Here are the three classes and when you should use them: |
|
|
|
|
|
|
|
|
|
All methods raise an FdtException if an error occurs. To avoid this |
|
|
|
|
behaviour a 'quiet' parameter is provided for some functions. This |
|
|
|
|
defaults to empty, but you can pass a list of errors that you expect. |
|
|
|
|
If one of these errors occurs, the function will return an error number |
|
|
|
|
(e.g. -NOTFOUND). |
|
|
|
|
FdtRo - read-only access to an existing FDT |
|
|
|
|
FdtRw - read-write access to an existing FDT (most common case) |
|
|
|
|
FdtSw - for creating a new FDT, as well as allowing read-only access |
|
|
|
|
""" |
|
|
|
|
def __init__(self, data): |
|
|
|
|
self._fdt = bytearray(data) |
|
|
|
|
@ -157,12 +154,14 @@ class Fdt: |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset of previous node |
|
|
|
|
depth: On input, the depth of the node at nodeoffset. On output, the |
|
|
|
|
depth of the returned node |
|
|
|
|
depth: The depth of the node at nodeoffset. This is used to |
|
|
|
|
calculate the depth of the returned node |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
The offset of the next node, if any |
|
|
|
|
Typle: |
|
|
|
|
Offset of the next node, if any, else a -ve error |
|
|
|
|
Depth of the returned node, if any, else undefined |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no more nodes found or other error occurs |
|
|
|
|
@ -205,7 +204,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Magic word |
|
|
|
|
""" |
|
|
|
|
return fdt_magic(self._fdt) & 0xffffffff |
|
|
|
|
return fdt_magic(self._fdt) |
|
|
|
|
|
|
|
|
|
def totalsize(self): |
|
|
|
|
"""Return the total size of the device tree |
|
|
|
|
@ -213,7 +212,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Total tree size in bytes |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_totalsize(self._fdt)) |
|
|
|
|
return fdt_totalsize(self._fdt) |
|
|
|
|
|
|
|
|
|
def off_dt_struct(self): |
|
|
|
|
"""Return the start of the device-tree struct area |
|
|
|
|
@ -221,7 +220,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Start offset of struct area |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_off_dt_struct(self._fdt)) |
|
|
|
|
return fdt_off_dt_struct(self._fdt) |
|
|
|
|
|
|
|
|
|
def off_dt_strings(self): |
|
|
|
|
"""Return the start of the device-tree string area |
|
|
|
|
@ -229,7 +228,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Start offset of string area |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_off_dt_strings(self._fdt)) |
|
|
|
|
return fdt_off_dt_strings(self._fdt) |
|
|
|
|
|
|
|
|
|
def off_mem_rsvmap(self): |
|
|
|
|
"""Return the start of the memory reserve map |
|
|
|
|
@ -237,7 +236,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Start offset of memory reserve map |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_off_mem_rsvmap(self._fdt)) |
|
|
|
|
return fdt_off_mem_rsvmap(self._fdt) |
|
|
|
|
|
|
|
|
|
def version(self): |
|
|
|
|
"""Return the version of the device tree |
|
|
|
|
@ -245,7 +244,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Version number of the device tree |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_version(self._fdt)) |
|
|
|
|
return fdt_version(self._fdt) |
|
|
|
|
|
|
|
|
|
def last_comp_version(self): |
|
|
|
|
"""Return the last compatible version of the device tree |
|
|
|
|
@ -253,7 +252,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Last compatible version number of the device tree |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_last_comp_version(self._fdt)) |
|
|
|
|
return fdt_last_comp_version(self._fdt) |
|
|
|
|
|
|
|
|
|
def boot_cpuid_phys(self): |
|
|
|
|
"""Return the physical boot CPU ID |
|
|
|
|
@ -261,7 +260,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Physical boot CPU ID |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_boot_cpuid_phys(self._fdt)) |
|
|
|
|
return fdt_boot_cpuid_phys(self._fdt) |
|
|
|
|
|
|
|
|
|
def size_dt_strings(self): |
|
|
|
|
"""Return the start of the device-tree string area |
|
|
|
|
@ -269,7 +268,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Start offset of string area |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_size_dt_strings(self._fdt)) |
|
|
|
|
return fdt_size_dt_strings(self._fdt) |
|
|
|
|
|
|
|
|
|
def size_dt_struct(self): |
|
|
|
|
"""Return the start of the device-tree struct area |
|
|
|
|
@ -277,7 +276,7 @@ class Fdt: |
|
|
|
|
Returns: |
|
|
|
|
Start offset of struct area |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_size_dt_struct(self._fdt)) |
|
|
|
|
return fdt_size_dt_struct(self._fdt) |
|
|
|
|
|
|
|
|
|
def num_mem_rsv(self, quiet=()): |
|
|
|
|
"""Return the number of memory reserve-map records |
|
|
|
|
@ -398,26 +397,90 @@ class Fdt: |
|
|
|
|
return pdata |
|
|
|
|
return Property(pdata[0], pdata[1]) |
|
|
|
|
|
|
|
|
|
def get_property(self, nodeoffset, prop_name, quiet=()): |
|
|
|
|
"""Obtains a property by name |
|
|
|
|
def getprop(self, nodeoffset, prop_name, quiet=()): |
|
|
|
|
"""Get a property from a node |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Offset to the node to check |
|
|
|
|
nodeoffset: Node offset containing property to get |
|
|
|
|
prop_name: Name of property to get |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
Property object, or None if not found |
|
|
|
|
Value of property as a Property object (which can be used as a |
|
|
|
|
bytearray/string), or -ve error number. On failure, returns an |
|
|
|
|
integer error |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException on error (e.g. invalid prop_offset or device |
|
|
|
|
tree format) |
|
|
|
|
FdtError if any error occurs (e.g. the property is not found) |
|
|
|
|
""" |
|
|
|
|
pdata = check_err_null( |
|
|
|
|
fdt_get_property(self._fdt, nodeoffset, prop_name), quiet) |
|
|
|
|
pdata = check_err_null(fdt_getprop(self._fdt, nodeoffset, prop_name), |
|
|
|
|
quiet) |
|
|
|
|
if isinstance(pdata, (int)): |
|
|
|
|
return pdata |
|
|
|
|
return Property(pdata[0], pdata[1]) |
|
|
|
|
return Property(prop_name, bytearray(pdata[0])) |
|
|
|
|
|
|
|
|
|
def get_phandle(self, nodeoffset): |
|
|
|
|
"""Get the phandle of a node |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset to check |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
phandle of node, or 0 if the node has no phandle or another error |
|
|
|
|
occurs |
|
|
|
|
""" |
|
|
|
|
return fdt_get_phandle(self._fdt, nodeoffset) |
|
|
|
|
|
|
|
|
|
def parent_offset(self, nodeoffset, quiet=()): |
|
|
|
|
"""Get the offset of a node's parent |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset to check |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
The offset of the parent node, if any |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no parent found or other error occurs |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_parent_offset(self._fdt, nodeoffset), quiet) |
|
|
|
|
|
|
|
|
|
def node_offset_by_phandle(self, phandle, quiet=()): |
|
|
|
|
"""Get the offset of a node with the given phandle |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
phandle: Phandle to search for |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
The offset of node with that phandle, if any |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_node_offset_by_phandle(self._fdt, phandle), quiet) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class Fdt(FdtRo): |
|
|
|
|
"""Device tree class, supporting all operations |
|
|
|
|
|
|
|
|
|
The Fdt object is created is created from a device tree binary file, |
|
|
|
|
e.g. with something like: |
|
|
|
|
|
|
|
|
|
fdt = Fdt(open("filename.dtb").read()) |
|
|
|
|
|
|
|
|
|
Operations can then be performed using the methods in this class. Each |
|
|
|
|
method xxx(args...) corresponds to a libfdt function fdt_xxx(fdt, args...). |
|
|
|
|
|
|
|
|
|
All methods raise an FdtException if an error occurs. To avoid this |
|
|
|
|
behaviour a 'quiet' parameter is provided for some functions. This |
|
|
|
|
defaults to empty, but you can pass a list of errors that you expect. |
|
|
|
|
If one of these errors occurs, the function will return an error number |
|
|
|
|
(e.g. -NOTFOUND). |
|
|
|
|
""" |
|
|
|
|
def __init__(self, data): |
|
|
|
|
FdtRo.__init__(self, data) |
|
|
|
|
|
|
|
|
|
@staticmethod |
|
|
|
|
def create_empty_tree(size, quiet=()): |
|
|
|
|
@ -435,18 +498,18 @@ class Fdt: |
|
|
|
|
return err |
|
|
|
|
return Fdt(data) |
|
|
|
|
|
|
|
|
|
def open_into(self, size, quiet=()): |
|
|
|
|
def resize(self, size, quiet=()): |
|
|
|
|
"""Move the device tree into a larger or smaller space |
|
|
|
|
|
|
|
|
|
This creates a new device tree of size @size and moves the existing |
|
|
|
|
device tree contents over to that. It can be used to create more space |
|
|
|
|
in a device tree. |
|
|
|
|
in a device tree. Note that the Fdt object remains the same, but it |
|
|
|
|
now has a new bytearray holding the contents. |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
size: Required new size of device tree in bytes |
|
|
|
|
""" |
|
|
|
|
fdt = bytearray(size) |
|
|
|
|
fdt[:len(self._fdt)] = self._fdt |
|
|
|
|
err = check_err(fdt_open_into(self._fdt, fdt, size), quiet) |
|
|
|
|
if err: |
|
|
|
|
return err |
|
|
|
|
@ -460,6 +523,9 @@ class Fdt: |
|
|
|
|
Args: |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
Error code, or 0 if OK |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if any error occurs |
|
|
|
|
""" |
|
|
|
|
@ -469,79 +535,12 @@ class Fdt: |
|
|
|
|
del self._fdt[self.totalsize():] |
|
|
|
|
return err |
|
|
|
|
|
|
|
|
|
def getprop(self, nodeoffset, prop_name, quiet=()): |
|
|
|
|
"""Get a property from a node |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset containing property to get |
|
|
|
|
prop_name: Name of property to get |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
Value of property as a string, or -ve error number |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtError if any error occurs (e.g. the property is not found) |
|
|
|
|
""" |
|
|
|
|
pdata = check_err_null(fdt_getprop(self._fdt, nodeoffset, prop_name), |
|
|
|
|
quiet) |
|
|
|
|
if isinstance(pdata, (int)): |
|
|
|
|
return pdata |
|
|
|
|
return str(pdata[0]) |
|
|
|
|
|
|
|
|
|
def getprop_obj(self, nodeoffset, prop_name, quiet=()): |
|
|
|
|
"""Get a property from a node as a Property object |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset containing property to get |
|
|
|
|
prop_name: Name of property to get |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
Property object, or None if not found |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtError if any error occurs (e.g. the property is not found) |
|
|
|
|
""" |
|
|
|
|
pdata = check_err_null(fdt_getprop(self._fdt, nodeoffset, prop_name), |
|
|
|
|
quiet) |
|
|
|
|
if isinstance(pdata, (int)): |
|
|
|
|
return None |
|
|
|
|
return Property(prop_name, bytearray(pdata[0])) |
|
|
|
|
|
|
|
|
|
def get_phandle(self, nodeoffset): |
|
|
|
|
"""Get the phandle of a node |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset to check |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
phandle of node, or 0 if the node has no phandle or another error |
|
|
|
|
occurs |
|
|
|
|
""" |
|
|
|
|
return fdt_get_phandle(self._fdt, nodeoffset) |
|
|
|
|
|
|
|
|
|
def parent_offset(self, nodeoffset, quiet=()): |
|
|
|
|
"""Get the offset of a node's parent |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset to check |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
The offset of the parent node, if any |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no parent found or other error occurs |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_parent_offset(self._fdt, nodeoffset), quiet) |
|
|
|
|
|
|
|
|
|
def set_name(self, nodeoffset, name, quiet=()): |
|
|
|
|
"""Set the name of a node |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset of node to update |
|
|
|
|
name: New node name |
|
|
|
|
name: New node name (string without \0) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
Error code, or 0 if OK |
|
|
|
|
@ -549,6 +548,8 @@ class Fdt: |
|
|
|
|
Raises: |
|
|
|
|
FdtException if no parent found or other error occurs |
|
|
|
|
""" |
|
|
|
|
if chr(0) in name: |
|
|
|
|
raise ValueError('Property contains embedded nul characters') |
|
|
|
|
return check_err(fdt_set_name(self._fdt, nodeoffset, name), quiet) |
|
|
|
|
|
|
|
|
|
def setprop(self, nodeoffset, prop_name, val, quiet=()): |
|
|
|
|
@ -613,7 +614,8 @@ class Fdt: |
|
|
|
|
Args: |
|
|
|
|
nodeoffset: Node offset containing the property to create/update |
|
|
|
|
prop_name: Name of property |
|
|
|
|
val: Value to write (string without nul terminator) |
|
|
|
|
val: Value to write (string without nul terminator). Unicode is |
|
|
|
|
supposed by encoding to UTF-8 |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
@ -622,7 +624,7 @@ class Fdt: |
|
|
|
|
Raises: |
|
|
|
|
FdtException if no parent found or other error occurs |
|
|
|
|
""" |
|
|
|
|
val += '\0' |
|
|
|
|
val = val.encode('utf-8') + '\0' |
|
|
|
|
return check_err(fdt_setprop(self._fdt, nodeoffset, prop_name, |
|
|
|
|
val, len(val)), quiet) |
|
|
|
|
|
|
|
|
|
@ -638,21 +640,6 @@ class Fdt: |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_delprop(self._fdt, nodeoffset, prop_name)) |
|
|
|
|
|
|
|
|
|
def node_offset_by_phandle(self, phandle, quiet=()): |
|
|
|
|
"""Get the offset of a node with the given phandle |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
phandle: Phandle to search for |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
The offset of node with that phandle, if any |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_node_offset_by_phandle(self._fdt, phandle), quiet) |
|
|
|
|
|
|
|
|
|
def del_node(self, nodeoffset): |
|
|
|
|
"""Delete a node |
|
|
|
|
|
|
|
|
|
@ -696,16 +683,20 @@ class Property(bytearray): |
|
|
|
|
return self.as_cell('q') |
|
|
|
|
|
|
|
|
|
def as_str(self): |
|
|
|
|
return self[:-1] |
|
|
|
|
"""Unicode is supported by decoding from UTF-8""" |
|
|
|
|
if self[-1] != 0: |
|
|
|
|
raise ValueError('Property lacks nul termination') |
|
|
|
|
if 0 in self[:-1]: |
|
|
|
|
raise ValueError('Property contains embedded nul characters') |
|
|
|
|
return self[:-1].decode('utf-8') |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class FdtSw(object): |
|
|
|
|
class FdtSw(FdtRo): |
|
|
|
|
"""Software interface to create a device tree from scratch |
|
|
|
|
|
|
|
|
|
The methods in this class work by adding to an existing 'partial' device |
|
|
|
|
tree buffer of a fixed size created by instantiating this class. When the |
|
|
|
|
tree is complete, call finish() to complete the device tree so that it can |
|
|
|
|
be used. |
|
|
|
|
tree is complete, call as_fdt() to obtain a device tree ready to be used. |
|
|
|
|
|
|
|
|
|
Similarly with nodes, a new node is started with begin_node() and finished |
|
|
|
|
with end_node(). |
|
|
|
|
@ -713,58 +704,87 @@ class FdtSw(object): |
|
|
|
|
The context manager functions can be used to make this a bit easier: |
|
|
|
|
|
|
|
|
|
# First create the device tree with a node and property: |
|
|
|
|
with FdtSw(small_size) as sw: |
|
|
|
|
with sw.AddNode('node'): |
|
|
|
|
sw.property_u32('reg', 2) |
|
|
|
|
fdt = sw.AsFdt() |
|
|
|
|
sw = FdtSw() |
|
|
|
|
with sw.add_node('node'): |
|
|
|
|
sw.property_u32('reg', 2) |
|
|
|
|
fdt = sw.as_fdt() |
|
|
|
|
|
|
|
|
|
# Now we can use it as a real device tree |
|
|
|
|
fdt.setprop_u32(0, 'reg', 3) |
|
|
|
|
|
|
|
|
|
The size hint provides a starting size for the space to be used by the |
|
|
|
|
device tree. This will be increased automatically as needed as new items |
|
|
|
|
are added to the tree. |
|
|
|
|
""" |
|
|
|
|
def __init__(self, size, quiet=()): |
|
|
|
|
fdtrw = bytearray(size) |
|
|
|
|
err = check_err(fdt_create(fdtrw, size)) |
|
|
|
|
if err: |
|
|
|
|
return err |
|
|
|
|
self._fdtrw = fdtrw |
|
|
|
|
INC_SIZE = 1024 # Expand size by this much when out of space |
|
|
|
|
|
|
|
|
|
def __enter__(self): |
|
|
|
|
"""Contact manager to use to create a device tree via software""" |
|
|
|
|
return self |
|
|
|
|
def __init__(self, size_hint=None): |
|
|
|
|
"""Create a new FdtSw object |
|
|
|
|
|
|
|
|
|
def __exit__(self, type, value, traceback): |
|
|
|
|
check_err(fdt_finish(self._fdtrw)) |
|
|
|
|
Args: |
|
|
|
|
size_hint: A hint as to the initial size to use |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
ValueError if size_hint is negative |
|
|
|
|
|
|
|
|
|
def AsFdt(self): |
|
|
|
|
Returns: |
|
|
|
|
FdtSw object on success, else integer error code (if not raising) |
|
|
|
|
""" |
|
|
|
|
if not size_hint: |
|
|
|
|
size_hint = self.INC_SIZE |
|
|
|
|
fdtsw = bytearray(size_hint) |
|
|
|
|
err = check_err(fdt_create(fdtsw, size_hint)) |
|
|
|
|
if err: |
|
|
|
|
return err |
|
|
|
|
self._fdt = fdtsw |
|
|
|
|
|
|
|
|
|
def as_fdt(self): |
|
|
|
|
"""Convert a FdtSw into an Fdt so it can be accessed as normal |
|
|
|
|
|
|
|
|
|
Note that finish() must be called before this function will work. If |
|
|
|
|
you are using the context manager (see 'with' code in the FdtSw class |
|
|
|
|
comment) then this will happen automatically. |
|
|
|
|
Creates a new Fdt object from the work-in-progress device tree. This |
|
|
|
|
does not call fdt_finish() on the current object, so it is possible to |
|
|
|
|
add more nodes/properties and call as_fdt() again to get an updated |
|
|
|
|
tree. |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
Fdt object allowing access to the newly created device tree |
|
|
|
|
""" |
|
|
|
|
return Fdt(self._fdtrw) |
|
|
|
|
fdtsw = bytearray(self._fdt) |
|
|
|
|
check_err(fdt_finish(fdtsw)) |
|
|
|
|
return Fdt(fdtsw) |
|
|
|
|
|
|
|
|
|
def resize(self, size, quiet=()): |
|
|
|
|
def check_space(self, val): |
|
|
|
|
"""Check if we need to add more space to the FDT |
|
|
|
|
|
|
|
|
|
This should be called with the error code from an operation. If this is |
|
|
|
|
-NOSPACE then the FDT will be expanded to have more space, and True will |
|
|
|
|
be returned, indicating that the operation needs to be tried again. |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
val: Return value from the operation that was attempted |
|
|
|
|
|
|
|
|
|
Returns: |
|
|
|
|
True if the operation must be retried, else False |
|
|
|
|
""" |
|
|
|
|
if check_err(val, QUIET_NOSPACE) < 0: |
|
|
|
|
self.resize(len(self._fdt) + self.INC_SIZE) |
|
|
|
|
return True |
|
|
|
|
return False |
|
|
|
|
|
|
|
|
|
def resize(self, size): |
|
|
|
|
"""Resize the buffer to accommodate a larger tree |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
size: New size of tree |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
fdt = bytearray(size) |
|
|
|
|
fdt[:len(self._fdtrw)] = self._fdtrw |
|
|
|
|
err = check_err(fdt_resize(self._fdtrw, fdt, size), quiet) |
|
|
|
|
if err: |
|
|
|
|
return err |
|
|
|
|
self._fdtrw = fdt |
|
|
|
|
err = check_err(fdt_resize(self._fdt, fdt, size)) |
|
|
|
|
self._fdt = fdt |
|
|
|
|
|
|
|
|
|
def add_reservemap_entry(self, addr, size, quiet=()): |
|
|
|
|
def add_reservemap_entry(self, addr, size): |
|
|
|
|
"""Add a new memory reserve map entry |
|
|
|
|
|
|
|
|
|
Once finished adding, you must call finish_reservemap(). |
|
|
|
|
@ -772,26 +792,24 @@ class FdtSw(object): |
|
|
|
|
Args: |
|
|
|
|
addr: 64-bit start address |
|
|
|
|
size: 64-bit size |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_add_reservemap_entry(self._fdtrw, addr, size), |
|
|
|
|
quiet) |
|
|
|
|
while self.check_space(fdt_add_reservemap_entry(self._fdt, addr, |
|
|
|
|
size)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def finish_reservemap(self, quiet=()): |
|
|
|
|
def finish_reservemap(self): |
|
|
|
|
"""Indicate that there are no more reserve map entries to add |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_finish_reservemap(self._fdtrw), quiet) |
|
|
|
|
while self.check_space(fdt_finish_reservemap(self._fdt)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def begin_node(self, name, quiet=()): |
|
|
|
|
def begin_node(self, name): |
|
|
|
|
"""Begin a new node |
|
|
|
|
|
|
|
|
|
Use this before adding properties to the node. Then call end_node() to |
|
|
|
|
@ -800,14 +818,14 @@ class FdtSw(object): |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
name: Name of node to begin |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_begin_node(self._fdtrw, name), quiet) |
|
|
|
|
while self.check_space(fdt_begin_node(self._fdt, name)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def property_string(self, name, string, quiet=()): |
|
|
|
|
def property_string(self, name, string): |
|
|
|
|
"""Add a property with a string value |
|
|
|
|
|
|
|
|
|
The string will be nul-terminated when written to the device tree |
|
|
|
|
@ -815,14 +833,14 @@ class FdtSw(object): |
|
|
|
|
Args: |
|
|
|
|
name: Name of property to add |
|
|
|
|
string: String value of property |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_property_string(self._fdtrw, name, string), quiet) |
|
|
|
|
while self.check_space(fdt_property_string(self._fdt, name, string)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def property_u32(self, name, val, quiet=()): |
|
|
|
|
def property_u32(self, name, val): |
|
|
|
|
"""Add a property with a 32-bit value |
|
|
|
|
|
|
|
|
|
Write a single-cell value to the device tree |
|
|
|
|
@ -830,14 +848,14 @@ class FdtSw(object): |
|
|
|
|
Args: |
|
|
|
|
name: Name of property to add |
|
|
|
|
val: Value of property |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_property_u32(self._fdtrw, name, val), quiet) |
|
|
|
|
while self.check_space(fdt_property_u32(self._fdt, name, val)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def property_u64(self, name, val, quiet=()): |
|
|
|
|
def property_u64(self, name, val): |
|
|
|
|
"""Add a property with a 64-bit value |
|
|
|
|
|
|
|
|
|
Write a double-cell value to the device tree in big-endian format |
|
|
|
|
@ -845,14 +863,14 @@ class FdtSw(object): |
|
|
|
|
Args: |
|
|
|
|
name: Name of property to add |
|
|
|
|
val: Value of property |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_property_u64(self._fdtrw, name, val), quiet) |
|
|
|
|
while self.check_space(fdt_property_u64(self._fdt, name, val)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def property_cell(self, name, val, quiet=()): |
|
|
|
|
def property_cell(self, name, val): |
|
|
|
|
"""Add a property with a single-cell value |
|
|
|
|
|
|
|
|
|
Write a single-cell value to the device tree |
|
|
|
|
@ -863,11 +881,12 @@ class FdtSw(object): |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_property_cell(self._fdtrw, name, val), quiet) |
|
|
|
|
while self.check_space(fdt_property_cell(self._fdt, name, val)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def property(self, name, val, quiet=()): |
|
|
|
|
def property(self, name, val): |
|
|
|
|
"""Add a property |
|
|
|
|
|
|
|
|
|
Write a new property with the given value to the device tree. The value |
|
|
|
|
@ -879,11 +898,13 @@ class FdtSw(object): |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(_fdt_property(self._fdtrw, name, val, len(val)), quiet) |
|
|
|
|
while self.check_space(fdt_property_stub(self._fdt, name, val, |
|
|
|
|
len(val))): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def end_node(self, quiet=()): |
|
|
|
|
def end_node(self): |
|
|
|
|
"""End a node |
|
|
|
|
|
|
|
|
|
Use this after adding properties to a node to close it off. You can also |
|
|
|
|
@ -893,24 +914,12 @@ class FdtSw(object): |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_end_node(self._fdtrw), quiet) |
|
|
|
|
|
|
|
|
|
def finish(self, quiet=()): |
|
|
|
|
"""Finish writing the device tree |
|
|
|
|
|
|
|
|
|
This closes off the device tree ready for use |
|
|
|
|
|
|
|
|
|
Args: |
|
|
|
|
quiet: Errors to ignore (empty to raise on all errors) |
|
|
|
|
|
|
|
|
|
Raises: |
|
|
|
|
FdtException if no node found or other error occurs |
|
|
|
|
FdtException on any error |
|
|
|
|
""" |
|
|
|
|
return check_err(fdt_finish(self._fdtrw), quiet) |
|
|
|
|
while self.check_space(fdt_end_node(self._fdt)): |
|
|
|
|
pass |
|
|
|
|
|
|
|
|
|
def AddNode(self, name): |
|
|
|
|
def add_node(self, name): |
|
|
|
|
"""Create a new context for adding a node |
|
|
|
|
|
|
|
|
|
When used in a 'with' clause this starts a new node and finishes it |
|
|
|
|
@ -919,7 +928,7 @@ class FdtSw(object): |
|
|
|
|
Args: |
|
|
|
|
name: Name of node to add |
|
|
|
|
""" |
|
|
|
|
return NodeAdder(self._fdtrw, name) |
|
|
|
|
return NodeAdder(self, name) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class NodeAdder(): |
|
|
|
|
@ -927,26 +936,30 @@ class NodeAdder(): |
|
|
|
|
|
|
|
|
|
This allows you to add nodes in a more natural way: |
|
|
|
|
|
|
|
|
|
with fdtsw.AddNode('name'): |
|
|
|
|
with fdtsw.add_node('name'): |
|
|
|
|
fdtsw.property_string('test', 'value') |
|
|
|
|
|
|
|
|
|
The node is automatically completed with a call to end_node() when the |
|
|
|
|
context exits. |
|
|
|
|
""" |
|
|
|
|
def __init__(self, fdt, name): |
|
|
|
|
self._fdt = fdt |
|
|
|
|
def __init__(self, fdtsw, name): |
|
|
|
|
self._fdt = fdtsw |
|
|
|
|
self._name = name |
|
|
|
|
|
|
|
|
|
def __enter__(self): |
|
|
|
|
check_err(fdt_begin_node(self._fdt, self._name)) |
|
|
|
|
self._fdt.begin_node(self._name) |
|
|
|
|
|
|
|
|
|
def __exit__(self, type, value, traceback): |
|
|
|
|
check_err(fdt_end_node(self._fdt)) |
|
|
|
|
self._fdt.end_node() |
|
|
|
|
%} |
|
|
|
|
|
|
|
|
|
%rename(fdt_property) fdt_property_func; |
|
|
|
|
|
|
|
|
|
typedef int fdt32_t; |
|
|
|
|
/* |
|
|
|
|
* fdt32_t is a big-endian 32-bit value defined to uint32_t in libfdt_env.h |
|
|
|
|
* so use the same type here. |
|
|
|
|
*/ |
|
|
|
|
typedef uint32_t fdt32_t; |
|
|
|
|
|
|
|
|
|
%include "libfdt/fdt.h" |
|
|
|
|
|
|
|
|
|
@ -1039,16 +1052,17 @@ typedef int fdt32_t; |
|
|
|
|
%warnfilter(302) fdt_property; |
|
|
|
|
|
|
|
|
|
/* These are macros in the header so have to be redefined here */ |
|
|
|
|
int fdt_magic(const void *fdt); |
|
|
|
|
int fdt_totalsize(const void *fdt); |
|
|
|
|
int fdt_off_dt_struct(const void *fdt); |
|
|
|
|
int fdt_off_dt_strings(const void *fdt); |
|
|
|
|
int fdt_off_mem_rsvmap(const void *fdt); |
|
|
|
|
int fdt_version(const void *fdt); |
|
|
|
|
int fdt_last_comp_version(const void *fdt); |
|
|
|
|
int fdt_boot_cpuid_phys(const void *fdt); |
|
|
|
|
int fdt_size_dt_strings(const void *fdt); |
|
|
|
|
int fdt_size_dt_struct(const void *fdt); |
|
|
|
|
uint32_t fdt_magic(const void *fdt); |
|
|
|
|
uint32_t fdt_totalsize(const void *fdt); |
|
|
|
|
uint32_t fdt_off_dt_struct(const void *fdt); |
|
|
|
|
uint32_t fdt_off_dt_strings(const void *fdt); |
|
|
|
|
uint32_t fdt_off_mem_rsvmap(const void *fdt); |
|
|
|
|
uint32_t fdt_version(const void *fdt); |
|
|
|
|
uint32_t fdt_last_comp_version(const void *fdt); |
|
|
|
|
uint32_t fdt_boot_cpuid_phys(const void *fdt); |
|
|
|
|
uint32_t fdt_size_dt_strings(const void *fdt); |
|
|
|
|
uint32_t fdt_size_dt_struct(const void *fdt); |
|
|
|
|
|
|
|
|
|
int fdt_property_string(void *fdt, const char *name, const char *val); |
|
|
|
|
int fdt_property_cell(void *fdt, const char *name, uint32_t val); |
|
|
|
|
|
|
|
|
|
@ -1056,6 +1070,6 @@ int fdt_property_cell(void *fdt, const char *name, uint32_t val); |
|
|
|
|
* This function has a stub since the name fdt_property is used for both a |
|
|
|
|
* function and a struct, which confuses SWIG. |
|
|
|
|
*/ |
|
|
|
|
int _fdt_property(void *fdt, const char *name, const char *val, int len); |
|
|
|
|
int fdt_property_stub(void *fdt, const char *name, const char *val, int len); |
|
|
|
|
|
|
|
|
|
%include <../libfdt/libfdt.h> |
|
|
|
|
|
Tom Rini
6 years ago