|
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] Re: [Xen-devel] [PATCH V1 09/29] xen/dts: Add new helpers to use the device tree
On Wed, 2013-08-28 at 15:47 +0100, Julien Grall wrote:
> List of new helpers taken from linux (commit 74b9272):
> - dt_property_read_string
> - dt_match_node
> - dt_find_maching_node
> - dt_device_is_available
> - dt_prop_cmp
>
> Other new helpers:
> - dt_set_cell
> - for_each_child
This seems too generic. Perhaps dt_for_each_child or for_each_dt_child?
> - dt_set_range
> - dt_cells_to_size
> - dt_next_cell
> - dt_get_range
> - dt_node_name_is_equal
> - dt_node_path_is_equal
> - dt_property_name_is_equal
>
> Signed-off-by: Julien Grall <julien.grall@xxxxxxxxxx>
>
> ---
> Changes in v2:
> - Update commit message
> - Add for_each_child
> - Add dt_get_range
> - Update documentation
> - Typoes
> ---
> xen/common/device_tree.c | 109 +++++++++++++++++++++++++++--
> xen/include/xen/device_tree.h | 151
> ++++++++++++++++++++++++++++++++++++++++-
> 2 files changed, 252 insertions(+), 8 deletions(-)
>
> diff --git a/xen/common/device_tree.c b/xen/common/device_tree.c
> index 07a19ac..833d67d 100644
> --- a/xen/common/device_tree.c
> +++ b/xen/common/device_tree.c
> @@ -182,23 +182,38 @@ void __init device_tree_get_reg(const u32 **cell, u32
> address_cells,
> get_val(cell, size_cells, size);
> }
>
> -static void __init set_val(u32 **cell, u32 cells, u64 val)
> +void dt_get_range(const __be32 **cell, const struct dt_device_node *np,
> + u64 *address, u64 *size)
> {
> - u32 c = cells;
> + *address = dt_next_cell(dt_n_addr_cells(np), cell);
> + *size = dt_next_cell(dt_n_size_cells(np), cell);
> +}
> +
> +void dt_set_cell(__be32 **cellp, int size, u64 val)
> +{
> + int cells = size;
>
> - while ( c-- )
> + while ( size-- )
> {
> - (*cell)[c] = cpu_to_fdt32(val);
> + (*cellp)[size] = cpu_to_fdt32(val);
> val >>= 32;
> }
> - (*cell) += cells;
> +
> + (*cellp) += cells;
> }
>
> void __init device_tree_set_reg(u32 **cell, u32 address_cells, u32
> size_cells,
> u64 start, u64 size)
> {
> - set_val(cell, address_cells, start);
> - set_val(cell, size_cells, size);
> + dt_set_cell(cell, address_cells, start);
> + dt_set_cell(cell, size_cells, size);
> +}
> +
> +void dt_set_range(__be32 **cellp, const struct dt_device_node *np,
> + u64 address, u64 size)
> +{
> + dt_set_cell(cellp, dt_n_addr_cells(np), address);
> + dt_set_cell(cellp, dt_n_size_cells(np), size);
> }
>
> u32 __init device_tree_get_u32(const void *fdt, int node, const char
> *prop_name,
> @@ -583,6 +598,23 @@ bool_t dt_property_read_u32(const struct dt_device_node
> *np,
> return 1;
> }
>
> +int dt_property_read_string(const struct dt_device_node *np,
> + const char *propname, const char **out_string)
> +{
> + const struct dt_property *pp = dt_find_property(np, propname, NULL);
> +
> + if ( !pp )
> + return -EINVAL;
> + if ( !pp->value )
> + return -ENODATA;
> + if ( strnlen(pp->value, pp->length) >= pp->length )
> + return -EILSEQ;
> +
> + *out_string = pp->value;
> +
> + return 0;
> +}
> +
> bool_t dt_device_is_compatible(const struct dt_device_node *device,
> const char *compat)
> {
> @@ -655,6 +687,34 @@ struct dt_device_node *dt_find_node_by_alias(const char
> *alias)
> return NULL;
> }
>
> +bool_t dt_match_node(const struct dt_device_match *matches,
> + const struct dt_device_node *node)
> +{
> + if ( !matches )
> + return 0;
> +
> + while ( matches->path || matches->type || matches->compatible )
> + {
> + bool_t match = 1;
> +
> + if ( matches->path )
> + match &= dt_node_path_is_equal(node, matches->path);
> +
> + if ( matches->type )
> + match &= dt_device_type_is_equal(node, matches->type);
> +
> + if ( matches->compatible )
> + match &= dt_device_is_compatible(node, matches->compatible);
> +
> + if ( match )
> + return match;
> +
> + matches++;
> + }
> +
> + return 0;
> +}
> +
> const struct dt_device_node *dt_get_parent(const struct dt_device_node *node)
> {
> if ( !node )
> @@ -684,6 +744,23 @@ dt_find_compatible_node(struct dt_device_node *from,
> return np;
> }
>
> +struct dt_device_node *
> +dt_find_matching_node(struct dt_device_node *from,
> + const struct dt_device_match *matches)
> +{
> + struct dt_device_node *np;
> + struct dt_device_node *dt;
> +
> + dt = from ? from->allnext : dt_host;
> + for_each_device_node(dt, np)
> + {
> + if ( dt_match_node(matches, np) )
> + return np;
> + }
> +
> + return NULL;
> +}
> +
> int dt_n_addr_cells(const struct dt_device_node *np)
> {
> const __be32 *ip;
> @@ -1372,6 +1449,24 @@ int dt_device_get_irq(const struct dt_device_node
> *device, int index,
> return dt_irq_translate(&raw, out_irq);
> }
>
> +bool_t dt_device_is_available(const struct dt_device_node *device)
> +{
> + const char *status;
> + u32 statlen;
> +
> + status = dt_get_property(device, "status", &statlen);
> + if ( status == NULL )
> + return 1;
> +
> + if ( statlen > 0 )
> + {
> + if ( !strcmp(status, "okay") || !strcmp(status, "ok") )
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> /**
> * unflatten_dt_node - Alloc and populate a device_node from the flat tree
> * @fdt: The parent device tree blob
> diff --git a/xen/include/xen/device_tree.h b/xen/include/xen/device_tree.h
> index 7cbf736..fa4f314 100644
> --- a/xen/include/xen/device_tree.h
> +++ b/xen/include/xen/device_tree.h
> @@ -54,6 +54,19 @@ struct dt_early_info {
> struct dt_module_info modules;
> };
>
> +/*
> + * Struct used for matching a device
> + */
> +struct dt_device_match {
> + const char *path;
> + const char *type;
> + const char *compatible;
> +};
> +
> +#define DT_MATCH_PATH(p) { .path = p }
> +#define DT_MATCH_TYPE(typ) { .type = typ }
> +#define DT_MATCH_COMPATIBLE(compat) { .compatible = compat }
> +
> typedef u32 dt_phandle;
>
> /**
> @@ -229,6 +242,7 @@ extern const struct dt_device_node
> *dt_interrupt_controller;
> */
> struct dt_device_node * __init dt_find_interrupt_controller(const char
> *compat);
>
> +#define dt_prop_cmp(s1, s2) strcmp((s1), (s2))
> #define dt_node_cmp(s1, s2) strcasecmp((s1), (s2))
> #define dt_compat_cmp(s1, s2) strcasecmp((s1), (s2))
>
> @@ -242,6 +256,9 @@ struct dt_device_node * __init
> dt_find_interrupt_controller(const char *compat);
> #define for_each_device_node(dt, dn) \
> for ( dn = dt; dn != NULL; dn = dn->allnext )
>
> +#define for_each_child_node(dt, dn) \
> + for ( dn = dt->child; dn != NULL; dn = dn->sibling )
> +
> /* Helper to read a big number; size is in cells (not bytes) */
> static inline u64 dt_read_number(const __be32 *cell, int size)
> {
> @@ -252,6 +269,20 @@ static inline u64 dt_read_number(const __be32 *cell, int
> size)
> return r;
> }
>
> +/* Helper to convert a number of cells in bytes */
> +static inline int dt_cells_to_size(int size)
> +{
> + return (size * sizeof (u32));
> +}
> +
> +static inline u64 dt_next_cell(int s, const __be32 **cellp)
> +{
> + const __be32 *p = *cellp;
> +
> + *cellp = p + s;
> + return dt_read_number(p, s);
> +}
> +
> static inline const char *dt_node_full_name(const struct dt_device_node *np)
> {
> return (np && np->full_name) ? np->full_name : "<no-node>";
> @@ -262,6 +293,18 @@ static inline const char *dt_node_name(const struct
> dt_device_node *np)
> return (np && np->name) ? np->name : "<no-node>";
> }
>
> +static inline bool_t dt_node_name_is_equal(const struct dt_device_node *np,
> + const char *name)
> +{
> + return !dt_node_cmp(np->name, name);
> +}
> +
> +static inline bool_t dt_node_path_is_equal(const struct dt_device_node *np,
> + const char *path)
> +{
> + return !dt_node_cmp(np->full_name, path);
> +}
> +
> static inline bool_t
> dt_device_type_is_equal(const struct dt_device_node *device,
> const char *type)
> @@ -281,6 +324,12 @@ static inline domid_t dt_device_used_by(const struct
> dt_device_node *device)
> return device->used_by;
> }
>
> +static inline bool_t dt_property_name_is_equal(const struct dt_property *pp,
> + const char *name)
> +{
> + return !dt_prop_cmp(pp->name, name);
> +}
> +
> /**
> * dt_find_compatible_node - Find a node based on type and one of the
> * tokens in its "compatible" property
> @@ -315,6 +364,23 @@ const void *dt_get_property(const struct dt_device_node
> *np,
> */
> bool_t dt_property_read_u32(const struct dt_device_node *np,
> const char *name, u32 *out_value);
> +/**
> + * dt_property_read_string - Find and read a string from a property
> + * @np: Device node from which the property value is to be read
> + * @propname: Name of the property to be searched
> + * @out_string: Pointer to null terminated return string, modified only
> + * if return value if 0.
> + *
> + * Search for a property in a device tree node and retrieve a null
> + * terminated string value (pointer to data, not a copy). Returns 0 on
> + * success, -EINVAL if the property does not exist, -ENODATA if property
> + * doest not have value, and -EILSEQ if the string is not
> + * null-terminated with the length of the property data.
> + *
> + * The out_string pointer is modified only if a valid string can be decoded.
> + */
> +int dt_property_read_string(const struct dt_device_node *np,
> + const char *propname, const char **out_string);
>
> /**
> * Checks if the given "compat" string matches one of the strings in
> @@ -450,4 +516,87 @@ int dt_n_size_cells(const struct dt_device_node *np);
> */
> int dt_n_addr_cells(const struct dt_device_node *np);
>
> -#endif
> +/**
> + * dt_device_is_available - Check if a device is available for use
> + *
> + * @device: Node to check for availability
> + *
> + * Returns true if the status property is absent or set to "okay" or "ok",
> + * false otherwise.
> + */
> +bool_t dt_device_is_available(const struct dt_device_node *device);
> +
> +/**
> + * dt_match_node - Tell if a device_node has a matching of dt_device_match
> + * @matches: array of dt_device_match structures to search in
> + * @node: the dt_device_node structure to match against
> + *
> + * Returns true if the device node match one of dt_device_match.
> + */
> +bool_t dt_match_node(const struct dt_device_match *matches,
> + const struct dt_device_node *node);
> +
> +/**
> + * dt_find_matching_node - Find a node based on an dt_device_match match
> table
> + * @from: The node to start searching from or NULL, the node you pass
> + * will not be searched, only the next one will; typically, you pass
> + * what the returned call returned
> + * @matches: array of dt_device_match structures to search in
> + *
> + * Returns a node pointer.
> + */
> +struct dt_device_node *
> +dt_find_matching_node(struct dt_device_node *from,
> + const struct dt_device_match *matches);
> +
> +/**
> + * dt_set_cell - Write a value into a series of cells
> + *
> + * @cellp: Pointer to cells
> + * @size: number of cells to write the value
> + * @value: number to write
> + *
> + * Write a value into a series of cells and update cellp to point to the
> + * cell just after.
> + */
> +void dt_set_cell(__be32 **cellp, int size, u64 val);
> +
> +/**
> + * dt_set_range - Write range into a series of cells
> + *
> + * @cellp: Pointer to cells
> + * @np: Node which contains the encoding for the address and the size
> + * @address: Start of range
> + * @size: Size of the range
> + *
> + * Write a range into a series of cells and update cellp to point to the
> + * cell just after.
> + */
> +void dt_set_range(__be32 **cellp, const struct dt_device_node *np,
> + u64 address, u64 size);
> +
> +/**
> + * dt_get_range - Read a range (address/size) from a series of cells
> + *
> + * @cellp: Pointer to cells
> + * @np Node which contains the encoding for the addresss and the size
> + * @address: Address filled by this function
> + * @size: Size filled by this function
> + *
> + * WARNING: This function should not be used to decode an address
> + * This function reads a range (address/size) from a series of cells and
> + * update cellp to point to the cell just after.
> + */
> +void dt_get_range(const __be32 **cellp, const struct dt_device_node *np,
> + u64 *address, u64 *size);
> +
> +#endif /* __XEN_DEVICE_TREE_H */
> +
> +/*
> + * Local variables:
> + * mode: C
> + * c-file-style: "BSD"
> + * c-basic-offset: 4
> + * indent-tabs-mode: nil
> + * End:
> + */
_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel
|
 |
Lists.xenproject.org is hosted with RackSpace, monitoring our |