From patchwork Fri Aug 16 21:05:41 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Julien Grall X-Patchwork-Id: 19257 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-yh0-f70.google.com (mail-yh0-f70.google.com [209.85.213.70]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id AFD8025A1B for ; Fri, 16 Aug 2013 21:06:22 +0000 (UTC) Received: by mail-yh0-f70.google.com with SMTP id i72sf1018258yha.5 for ; Fri, 16 Aug 2013 14:06:22 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=mime-version:x-gm-message-state:delivered-to:from:to:cc:subject :date:message-id:in-reply-to:references:x-original-sender :x-original-authentication-results:precedence:mailing-list:list-id :list-post:list-help:list-archive:list-unsubscribe; bh=kvi1r/jlkZuPJ9ZsyoRvN3mVZx0Zuf2/NSmr4idFP7w=; b=W1pZr8fH7IW9idQQqfEhY8KsIMP+Qvun7iY4/7efspPC0qEer0DeMSDJ7O90xZcMMo 5tQ8XjU+yS2cYhH0lqWU5an6Ctp/nOW+iBJCA/4P/TDKlo33gFE1XWzKdT2cDRV/ebD5 JRTPjrJB810tmaahWRed6w0ieNyhRN6o4kGakKswdx7CBdigyFZKpIE3QQegGWHzc50+ m9l6bn0VNaWGnNbP4DSW783a91+L8nYcXwt5J2f4FylslIVOU3fKjE7uSAPTB60fLJDC iadz19iK0pHhLe+KlwTxT1+uWaBo/YRpGIfheyloTT9scn9+3e+f5FEBy/RUoxSBTvBb rB9Q== X-Received: by 10.236.63.165 with SMTP id a25mr1253912yhd.43.1376687182407; Fri, 16 Aug 2013 14:06:22 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.49.71.168 with SMTP id w8ls940230qeu.64.gmail; Fri, 16 Aug 2013 14:06:22 -0700 (PDT) X-Received: by 10.52.103.35 with SMTP id ft3mr2479213vdb.5.1376687182261; Fri, 16 Aug 2013 14:06:22 -0700 (PDT) Received: from mail-ve0-f182.google.com (mail-ve0-f182.google.com [209.85.128.182]) by mx.google.com with ESMTPS id gq6si776828veb.91.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Fri, 16 Aug 2013 14:06:22 -0700 (PDT) Received-SPF: neutral (google.com: 209.85.128.182 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) client-ip=209.85.128.182; Received: by mail-ve0-f182.google.com with SMTP id m1so1716613ves.13 for ; Fri, 16 Aug 2013 14:06:22 -0700 (PDT) X-Gm-Message-State: ALoCoQlnQU1t+zvFdzGojUsIhLy39DntVPNK7edTVdfMUTI269gKwW8i2VK7C9XTiFNArPfuKp1q X-Received: by 10.58.80.7 with SMTP id n7mr2940449vex.23.1376687182157; Fri, 16 Aug 2013 14:06:22 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patches@linaro.org Received: by 10.220.174.196 with SMTP id u4csp89451vcz; Fri, 16 Aug 2013 14:06:21 -0700 (PDT) X-Received: by 10.180.35.38 with SMTP id e6mr595647wij.28.1376687181102; Fri, 16 Aug 2013 14:06:21 -0700 (PDT) Received: from mail-wg0-f53.google.com (mail-wg0-f53.google.com [74.125.82.53]) by mx.google.com with ESMTPS id o10si1282006wjz.142.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Fri, 16 Aug 2013 14:06:21 -0700 (PDT) Received-SPF: neutral (google.com: 74.125.82.53 is neither permitted nor denied by best guess record for domain of julien.grall@linaro.org) client-ip=74.125.82.53; Received: by mail-wg0-f53.google.com with SMTP id c11so1933993wgh.20 for ; Fri, 16 Aug 2013 14:06:20 -0700 (PDT) X-Received: by 10.194.78.78 with SMTP id z14mr2512073wjw.32.1376687180651; Fri, 16 Aug 2013 14:06:20 -0700 (PDT) Received: from belegaer.uk.xensource.com. ([185.25.64.249]) by mx.google.com with ESMTPSA id b13sm797327wic.9.1969.12.31.16.00.00 (version=TLSv1.2 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Fri, 16 Aug 2013 14:06:19 -0700 (PDT) From: Julien Grall To: stefano.stabellini@eu.citrix.com, ian.campbell@citrix.com Cc: patches@linaro.org, andre.przywara@linaro.org, xen-devel@lists.xen.org, Julien Grall Subject: [RFC 09/24] xen/dts: Add new helpers to use the device tree Date: Fri, 16 Aug 2013 22:05:41 +0100 Message-Id: <1376687156-6737-10-git-send-email-julien.grall@linaro.org> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1376687156-6737-1-git-send-email-julien.grall@linaro.org> References: <1376687156-6737-1-git-send-email-julien.grall@linaro.org> X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: julien.grall@linaro.org X-Original-Authentication-Results: mx.google.com; spf=neutral (google.com: 209.85.128.182 is neither permitted nor denied by best guess record for domain of patch+caf_=patchwork-forward=linaro.org@linaro.org) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Precedence: list Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org List-ID: X-Google-Group-Id: 836684582541 List-Post: , List-Help: , List-Archive: List-Unsubscribe: , Signed-off-by: Julien Grall --- xen/common/device_tree.c | 102 ++++++++++++++++++++++++++++--- xen/include/xen/device_tree.h | 135 ++++++++++++++++++++++++++++++++++++++++- 2 files changed, 228 insertions(+), 9 deletions(-) diff --git a/xen/common/device_tree.c b/xen/common/device_tree.c index 315b284..95635f0 100644 --- a/xen/common/device_tree.c +++ b/xen/common/device_tree.c @@ -182,23 +182,31 @@ 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_set_cell(__be32 **cellp, int size, u64 val) { - u32 c = cells; + 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, @@ -568,6 +576,23 @@ const void *dt_get_property(const struct dt_device_node *np, return pp ? pp->value : NULL; } +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) { @@ -640,6 +665,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 ) @@ -669,6 +722,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; @@ -1357,6 +1427,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 e6a82cb..22a2973 100644 --- a/xen/include/xen/device_tree.h +++ b/xen/include/xen/device_tree.h @@ -48,6 +48,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; /** @@ -223,6 +236,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)) @@ -246,6 +260,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 : ""; @@ -256,6 +284,18 @@ static inline const char *dt_node_name(const struct dt_device_node *np) return (np && np->name) ? np->name : ""; } +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) @@ -275,6 +315,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 @@ -295,11 +341,29 @@ struct dt_device_node *dt_find_compatible_node(struct dt_device_node *from, /** * Find a property with a given name for a given node * and return the value. - */ + */ const void *dt_get_property(const struct dt_device_node *np, const char *name, u32 *lenp); /** + * 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 + * sucess, -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 modifed 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 * the device's "compatible" property */ @@ -433,4 +497,71 @@ 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 serie of cells + * + * @cellp: Pointer to cells + * + * 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 serie 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 serie 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); + +#endif /* __XEN_DEVICE_TREE_H */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * indent-tabs-mode: nil + * End: + */