1af6074fcSRob Herring // SPDX-License-Identifier: GPL-2.0+ 21df09bc6SSakari Ailus /* 31df09bc6SSakari Ailus * drivers/of/property.c - Procedures for accessing and interpreting 41df09bc6SSakari Ailus * Devicetree properties and graphs. 51df09bc6SSakari Ailus * 61df09bc6SSakari Ailus * Initially created by copying procedures from drivers/of/base.c. This 71df09bc6SSakari Ailus * file contains the OF property as well as the OF graph interface 81df09bc6SSakari Ailus * functions. 91df09bc6SSakari Ailus * 101df09bc6SSakari Ailus * Paul Mackerras August 1996. 111df09bc6SSakari Ailus * Copyright (C) 1996-2005 Paul Mackerras. 121df09bc6SSakari Ailus * 131df09bc6SSakari Ailus * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner. 141df09bc6SSakari Ailus * {engebret|bergner}@us.ibm.com 151df09bc6SSakari Ailus * 161df09bc6SSakari Ailus * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net 171df09bc6SSakari Ailus * 181df09bc6SSakari Ailus * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and 191df09bc6SSakari Ailus * Grant Likely. 201df09bc6SSakari Ailus */ 211df09bc6SSakari Ailus 221df09bc6SSakari Ailus #define pr_fmt(fmt) "OF: " fmt 231df09bc6SSakari Ailus 241df09bc6SSakari Ailus #include <linux/of.h> 251df09bc6SSakari Ailus #include <linux/of_device.h> 261df09bc6SSakari Ailus #include <linux/of_graph.h> 271df09bc6SSakari Ailus #include <linux/string.h> 28a3e1d1a7SSaravana Kannan #include <linux/moduleparam.h> 291df09bc6SSakari Ailus 301df09bc6SSakari Ailus #include "of_private.h" 311df09bc6SSakari Ailus 321df09bc6SSakari Ailus /** 331df09bc6SSakari Ailus * of_property_count_elems_of_size - Count the number of elements in a property 341df09bc6SSakari Ailus * 351df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 361df09bc6SSakari Ailus * @propname: name of the property to be searched. 371df09bc6SSakari Ailus * @elem_size: size of the individual element 381df09bc6SSakari Ailus * 391df09bc6SSakari Ailus * Search for a property in a device node and count the number of elements of 401df09bc6SSakari Ailus * size elem_size in it. Returns number of elements on sucess, -EINVAL if the 411df09bc6SSakari Ailus * property does not exist or its length does not match a multiple of elem_size 421df09bc6SSakari Ailus * and -ENODATA if the property does not have a value. 431df09bc6SSakari Ailus */ 441df09bc6SSakari Ailus int of_property_count_elems_of_size(const struct device_node *np, 451df09bc6SSakari Ailus const char *propname, int elem_size) 461df09bc6SSakari Ailus { 471df09bc6SSakari Ailus struct property *prop = of_find_property(np, propname, NULL); 481df09bc6SSakari Ailus 491df09bc6SSakari Ailus if (!prop) 501df09bc6SSakari Ailus return -EINVAL; 511df09bc6SSakari Ailus if (!prop->value) 521df09bc6SSakari Ailus return -ENODATA; 531df09bc6SSakari Ailus 541df09bc6SSakari Ailus if (prop->length % elem_size != 0) { 550d638a07SRob Herring pr_err("size of %s in node %pOF is not a multiple of %d\n", 560d638a07SRob Herring propname, np, elem_size); 571df09bc6SSakari Ailus return -EINVAL; 581df09bc6SSakari Ailus } 591df09bc6SSakari Ailus 601df09bc6SSakari Ailus return prop->length / elem_size; 611df09bc6SSakari Ailus } 621df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_count_elems_of_size); 631df09bc6SSakari Ailus 641df09bc6SSakari Ailus /** 651df09bc6SSakari Ailus * of_find_property_value_of_size 661df09bc6SSakari Ailus * 671df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 681df09bc6SSakari Ailus * @propname: name of the property to be searched. 691df09bc6SSakari Ailus * @min: minimum allowed length of property value 701df09bc6SSakari Ailus * @max: maximum allowed length of property value (0 means unlimited) 711df09bc6SSakari Ailus * @len: if !=NULL, actual length is written to here 721df09bc6SSakari Ailus * 731df09bc6SSakari Ailus * Search for a property in a device node and valid the requested size. 741df09bc6SSakari Ailus * Returns the property value on success, -EINVAL if the property does not 751df09bc6SSakari Ailus * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the 761df09bc6SSakari Ailus * property data is too small or too large. 771df09bc6SSakari Ailus * 781df09bc6SSakari Ailus */ 791df09bc6SSakari Ailus static void *of_find_property_value_of_size(const struct device_node *np, 801df09bc6SSakari Ailus const char *propname, u32 min, u32 max, size_t *len) 811df09bc6SSakari Ailus { 821df09bc6SSakari Ailus struct property *prop = of_find_property(np, propname, NULL); 831df09bc6SSakari Ailus 841df09bc6SSakari Ailus if (!prop) 851df09bc6SSakari Ailus return ERR_PTR(-EINVAL); 861df09bc6SSakari Ailus if (!prop->value) 871df09bc6SSakari Ailus return ERR_PTR(-ENODATA); 881df09bc6SSakari Ailus if (prop->length < min) 891df09bc6SSakari Ailus return ERR_PTR(-EOVERFLOW); 901df09bc6SSakari Ailus if (max && prop->length > max) 911df09bc6SSakari Ailus return ERR_PTR(-EOVERFLOW); 921df09bc6SSakari Ailus 931df09bc6SSakari Ailus if (len) 941df09bc6SSakari Ailus *len = prop->length; 951df09bc6SSakari Ailus 961df09bc6SSakari Ailus return prop->value; 971df09bc6SSakari Ailus } 981df09bc6SSakari Ailus 991df09bc6SSakari Ailus /** 1001df09bc6SSakari Ailus * of_property_read_u32_index - Find and read a u32 from a multi-value property. 1011df09bc6SSakari Ailus * 1021df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 1031df09bc6SSakari Ailus * @propname: name of the property to be searched. 1041df09bc6SSakari Ailus * @index: index of the u32 in the list of values 1051df09bc6SSakari Ailus * @out_value: pointer to return value, modified only if no error. 1061df09bc6SSakari Ailus * 1071df09bc6SSakari Ailus * Search for a property in a device node and read nth 32-bit value from 1081df09bc6SSakari Ailus * it. Returns 0 on success, -EINVAL if the property does not exist, 1091df09bc6SSakari Ailus * -ENODATA if property does not have a value, and -EOVERFLOW if the 1101df09bc6SSakari Ailus * property data isn't large enough. 1111df09bc6SSakari Ailus * 1121df09bc6SSakari Ailus * The out_value is modified only if a valid u32 value can be decoded. 1131df09bc6SSakari Ailus */ 1141df09bc6SSakari Ailus int of_property_read_u32_index(const struct device_node *np, 1151df09bc6SSakari Ailus const char *propname, 1161df09bc6SSakari Ailus u32 index, u32 *out_value) 1171df09bc6SSakari Ailus { 1181df09bc6SSakari Ailus const u32 *val = of_find_property_value_of_size(np, propname, 1191df09bc6SSakari Ailus ((index + 1) * sizeof(*out_value)), 1201df09bc6SSakari Ailus 0, 1211df09bc6SSakari Ailus NULL); 1221df09bc6SSakari Ailus 1231df09bc6SSakari Ailus if (IS_ERR(val)) 1241df09bc6SSakari Ailus return PTR_ERR(val); 1251df09bc6SSakari Ailus 1261df09bc6SSakari Ailus *out_value = be32_to_cpup(((__be32 *)val) + index); 1271df09bc6SSakari Ailus return 0; 1281df09bc6SSakari Ailus } 1291df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_u32_index); 1301df09bc6SSakari Ailus 1311df09bc6SSakari Ailus /** 1321df09bc6SSakari Ailus * of_property_read_u64_index - Find and read a u64 from a multi-value property. 1331df09bc6SSakari Ailus * 1341df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 1351df09bc6SSakari Ailus * @propname: name of the property to be searched. 1361df09bc6SSakari Ailus * @index: index of the u64 in the list of values 1371df09bc6SSakari Ailus * @out_value: pointer to return value, modified only if no error. 1381df09bc6SSakari Ailus * 1391df09bc6SSakari Ailus * Search for a property in a device node and read nth 64-bit value from 1401df09bc6SSakari Ailus * it. Returns 0 on success, -EINVAL if the property does not exist, 1411df09bc6SSakari Ailus * -ENODATA if property does not have a value, and -EOVERFLOW if the 1421df09bc6SSakari Ailus * property data isn't large enough. 1431df09bc6SSakari Ailus * 1441df09bc6SSakari Ailus * The out_value is modified only if a valid u64 value can be decoded. 1451df09bc6SSakari Ailus */ 1461df09bc6SSakari Ailus int of_property_read_u64_index(const struct device_node *np, 1471df09bc6SSakari Ailus const char *propname, 1481df09bc6SSakari Ailus u32 index, u64 *out_value) 1491df09bc6SSakari Ailus { 1501df09bc6SSakari Ailus const u64 *val = of_find_property_value_of_size(np, propname, 1511df09bc6SSakari Ailus ((index + 1) * sizeof(*out_value)), 1521df09bc6SSakari Ailus 0, NULL); 1531df09bc6SSakari Ailus 1541df09bc6SSakari Ailus if (IS_ERR(val)) 1551df09bc6SSakari Ailus return PTR_ERR(val); 1561df09bc6SSakari Ailus 1571df09bc6SSakari Ailus *out_value = be64_to_cpup(((__be64 *)val) + index); 1581df09bc6SSakari Ailus return 0; 1591df09bc6SSakari Ailus } 1601df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_u64_index); 1611df09bc6SSakari Ailus 1621df09bc6SSakari Ailus /** 1631df09bc6SSakari Ailus * of_property_read_variable_u8_array - Find and read an array of u8 from a 1641df09bc6SSakari Ailus * property, with bounds on the minimum and maximum array size. 1651df09bc6SSakari Ailus * 1661df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 1671df09bc6SSakari Ailus * @propname: name of the property to be searched. 1681df09bc6SSakari Ailus * @out_values: pointer to return value, modified only if return value is 0. 1691df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 1701df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 1711df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 1721df09bc6SSakari Ailus * sz_min will be read. 1731df09bc6SSakari Ailus * 1741df09bc6SSakari Ailus * Search for a property in a device node and read 8-bit value(s) from 1751df09bc6SSakari Ailus * it. Returns number of elements read on success, -EINVAL if the property 1761df09bc6SSakari Ailus * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 1771df09bc6SSakari Ailus * if the property data is smaller than sz_min or longer than sz_max. 1781df09bc6SSakari Ailus * 1791df09bc6SSakari Ailus * dts entry of array should be like: 1801df09bc6SSakari Ailus * property = /bits/ 8 <0x50 0x60 0x70>; 1811df09bc6SSakari Ailus * 1821df09bc6SSakari Ailus * The out_values is modified only if a valid u8 value can be decoded. 1831df09bc6SSakari Ailus */ 1841df09bc6SSakari Ailus int of_property_read_variable_u8_array(const struct device_node *np, 1851df09bc6SSakari Ailus const char *propname, u8 *out_values, 1861df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 1871df09bc6SSakari Ailus { 1881df09bc6SSakari Ailus size_t sz, count; 1891df09bc6SSakari Ailus const u8 *val = of_find_property_value_of_size(np, propname, 1901df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 1911df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 1921df09bc6SSakari Ailus &sz); 1931df09bc6SSakari Ailus 1941df09bc6SSakari Ailus if (IS_ERR(val)) 1951df09bc6SSakari Ailus return PTR_ERR(val); 1961df09bc6SSakari Ailus 1971df09bc6SSakari Ailus if (!sz_max) 1981df09bc6SSakari Ailus sz = sz_min; 1991df09bc6SSakari Ailus else 2001df09bc6SSakari Ailus sz /= sizeof(*out_values); 2011df09bc6SSakari Ailus 2021df09bc6SSakari Ailus count = sz; 2031df09bc6SSakari Ailus while (count--) 2041df09bc6SSakari Ailus *out_values++ = *val++; 2051df09bc6SSakari Ailus 2061df09bc6SSakari Ailus return sz; 2071df09bc6SSakari Ailus } 2081df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array); 2091df09bc6SSakari Ailus 2101df09bc6SSakari Ailus /** 2111df09bc6SSakari Ailus * of_property_read_variable_u16_array - Find and read an array of u16 from a 2121df09bc6SSakari Ailus * property, with bounds on the minimum and maximum array size. 2131df09bc6SSakari Ailus * 2141df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 2151df09bc6SSakari Ailus * @propname: name of the property to be searched. 2161df09bc6SSakari Ailus * @out_values: pointer to return value, modified only if return value is 0. 2171df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 2181df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 2191df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 2201df09bc6SSakari Ailus * sz_min will be read. 2211df09bc6SSakari Ailus * 2221df09bc6SSakari Ailus * Search for a property in a device node and read 16-bit value(s) from 2231df09bc6SSakari Ailus * it. Returns number of elements read on success, -EINVAL if the property 2241df09bc6SSakari Ailus * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 2251df09bc6SSakari Ailus * if the property data is smaller than sz_min or longer than sz_max. 2261df09bc6SSakari Ailus * 2271df09bc6SSakari Ailus * dts entry of array should be like: 2281df09bc6SSakari Ailus * property = /bits/ 16 <0x5000 0x6000 0x7000>; 2291df09bc6SSakari Ailus * 2301df09bc6SSakari Ailus * The out_values is modified only if a valid u16 value can be decoded. 2311df09bc6SSakari Ailus */ 2321df09bc6SSakari Ailus int of_property_read_variable_u16_array(const struct device_node *np, 2331df09bc6SSakari Ailus const char *propname, u16 *out_values, 2341df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 2351df09bc6SSakari Ailus { 2361df09bc6SSakari Ailus size_t sz, count; 2371df09bc6SSakari Ailus const __be16 *val = of_find_property_value_of_size(np, propname, 2381df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 2391df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 2401df09bc6SSakari Ailus &sz); 2411df09bc6SSakari Ailus 2421df09bc6SSakari Ailus if (IS_ERR(val)) 2431df09bc6SSakari Ailus return PTR_ERR(val); 2441df09bc6SSakari Ailus 2451df09bc6SSakari Ailus if (!sz_max) 2461df09bc6SSakari Ailus sz = sz_min; 2471df09bc6SSakari Ailus else 2481df09bc6SSakari Ailus sz /= sizeof(*out_values); 2491df09bc6SSakari Ailus 2501df09bc6SSakari Ailus count = sz; 2511df09bc6SSakari Ailus while (count--) 2521df09bc6SSakari Ailus *out_values++ = be16_to_cpup(val++); 2531df09bc6SSakari Ailus 2541df09bc6SSakari Ailus return sz; 2551df09bc6SSakari Ailus } 2561df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array); 2571df09bc6SSakari Ailus 2581df09bc6SSakari Ailus /** 2591df09bc6SSakari Ailus * of_property_read_variable_u32_array - Find and read an array of 32 bit 2601df09bc6SSakari Ailus * integers from a property, with bounds on the minimum and maximum array size. 2611df09bc6SSakari Ailus * 2621df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 2631df09bc6SSakari Ailus * @propname: name of the property to be searched. 2641df09bc6SSakari Ailus * @out_values: pointer to return value, modified only if return value is 0. 2651df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 2661df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 2671df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 2681df09bc6SSakari Ailus * sz_min will be read. 2691df09bc6SSakari Ailus * 2701df09bc6SSakari Ailus * Search for a property in a device node and read 32-bit value(s) from 2711df09bc6SSakari Ailus * it. Returns number of elements read on success, -EINVAL if the property 2721df09bc6SSakari Ailus * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 2731df09bc6SSakari Ailus * if the property data is smaller than sz_min or longer than sz_max. 2741df09bc6SSakari Ailus * 2751df09bc6SSakari Ailus * The out_values is modified only if a valid u32 value can be decoded. 2761df09bc6SSakari Ailus */ 2771df09bc6SSakari Ailus int of_property_read_variable_u32_array(const struct device_node *np, 2781df09bc6SSakari Ailus const char *propname, u32 *out_values, 2791df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 2801df09bc6SSakari Ailus { 2811df09bc6SSakari Ailus size_t sz, count; 2821df09bc6SSakari Ailus const __be32 *val = of_find_property_value_of_size(np, propname, 2831df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 2841df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 2851df09bc6SSakari Ailus &sz); 2861df09bc6SSakari Ailus 2871df09bc6SSakari Ailus if (IS_ERR(val)) 2881df09bc6SSakari Ailus return PTR_ERR(val); 2891df09bc6SSakari Ailus 2901df09bc6SSakari Ailus if (!sz_max) 2911df09bc6SSakari Ailus sz = sz_min; 2921df09bc6SSakari Ailus else 2931df09bc6SSakari Ailus sz /= sizeof(*out_values); 2941df09bc6SSakari Ailus 2951df09bc6SSakari Ailus count = sz; 2961df09bc6SSakari Ailus while (count--) 2971df09bc6SSakari Ailus *out_values++ = be32_to_cpup(val++); 2981df09bc6SSakari Ailus 2991df09bc6SSakari Ailus return sz; 3001df09bc6SSakari Ailus } 3011df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array); 3021df09bc6SSakari Ailus 3031df09bc6SSakari Ailus /** 3041df09bc6SSakari Ailus * of_property_read_u64 - Find and read a 64 bit integer from a property 3051df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 3061df09bc6SSakari Ailus * @propname: name of the property to be searched. 3071df09bc6SSakari Ailus * @out_value: pointer to return value, modified only if return value is 0. 3081df09bc6SSakari Ailus * 3091df09bc6SSakari Ailus * Search for a property in a device node and read a 64-bit value from 3101df09bc6SSakari Ailus * it. Returns 0 on success, -EINVAL if the property does not exist, 3111df09bc6SSakari Ailus * -ENODATA if property does not have a value, and -EOVERFLOW if the 3121df09bc6SSakari Ailus * property data isn't large enough. 3131df09bc6SSakari Ailus * 3141df09bc6SSakari Ailus * The out_value is modified only if a valid u64 value can be decoded. 3151df09bc6SSakari Ailus */ 3161df09bc6SSakari Ailus int of_property_read_u64(const struct device_node *np, const char *propname, 3171df09bc6SSakari Ailus u64 *out_value) 3181df09bc6SSakari Ailus { 3191df09bc6SSakari Ailus const __be32 *val = of_find_property_value_of_size(np, propname, 3201df09bc6SSakari Ailus sizeof(*out_value), 3211df09bc6SSakari Ailus 0, 3221df09bc6SSakari Ailus NULL); 3231df09bc6SSakari Ailus 3241df09bc6SSakari Ailus if (IS_ERR(val)) 3251df09bc6SSakari Ailus return PTR_ERR(val); 3261df09bc6SSakari Ailus 3271df09bc6SSakari Ailus *out_value = of_read_number(val, 2); 3281df09bc6SSakari Ailus return 0; 3291df09bc6SSakari Ailus } 3301df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_u64); 3311df09bc6SSakari Ailus 3321df09bc6SSakari Ailus /** 3331df09bc6SSakari Ailus * of_property_read_variable_u64_array - Find and read an array of 64 bit 3341df09bc6SSakari Ailus * integers from a property, with bounds on the minimum and maximum array size. 3351df09bc6SSakari Ailus * 3361df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 3371df09bc6SSakari Ailus * @propname: name of the property to be searched. 3381df09bc6SSakari Ailus * @out_values: pointer to return value, modified only if return value is 0. 3391df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 3401df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 3411df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 3421df09bc6SSakari Ailus * sz_min will be read. 3431df09bc6SSakari Ailus * 3441df09bc6SSakari Ailus * Search for a property in a device node and read 64-bit value(s) from 3451df09bc6SSakari Ailus * it. Returns number of elements read on success, -EINVAL if the property 3461df09bc6SSakari Ailus * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 3471df09bc6SSakari Ailus * if the property data is smaller than sz_min or longer than sz_max. 3481df09bc6SSakari Ailus * 3491df09bc6SSakari Ailus * The out_values is modified only if a valid u64 value can be decoded. 3501df09bc6SSakari Ailus */ 3511df09bc6SSakari Ailus int of_property_read_variable_u64_array(const struct device_node *np, 3521df09bc6SSakari Ailus const char *propname, u64 *out_values, 3531df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 3541df09bc6SSakari Ailus { 3551df09bc6SSakari Ailus size_t sz, count; 3561df09bc6SSakari Ailus const __be32 *val = of_find_property_value_of_size(np, propname, 3571df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 3581df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 3591df09bc6SSakari Ailus &sz); 3601df09bc6SSakari Ailus 3611df09bc6SSakari Ailus if (IS_ERR(val)) 3621df09bc6SSakari Ailus return PTR_ERR(val); 3631df09bc6SSakari Ailus 3641df09bc6SSakari Ailus if (!sz_max) 3651df09bc6SSakari Ailus sz = sz_min; 3661df09bc6SSakari Ailus else 3671df09bc6SSakari Ailus sz /= sizeof(*out_values); 3681df09bc6SSakari Ailus 3691df09bc6SSakari Ailus count = sz; 3701df09bc6SSakari Ailus while (count--) { 3711df09bc6SSakari Ailus *out_values++ = of_read_number(val, 2); 3721df09bc6SSakari Ailus val += 2; 3731df09bc6SSakari Ailus } 3741df09bc6SSakari Ailus 3751df09bc6SSakari Ailus return sz; 3761df09bc6SSakari Ailus } 3771df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array); 3781df09bc6SSakari Ailus 3791df09bc6SSakari Ailus /** 3801df09bc6SSakari Ailus * of_property_read_string - Find and read a string from a property 3811df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 3821df09bc6SSakari Ailus * @propname: name of the property to be searched. 3831df09bc6SSakari Ailus * @out_string: pointer to null terminated return string, modified only if 3841df09bc6SSakari Ailus * return value is 0. 3851df09bc6SSakari Ailus * 3861df09bc6SSakari Ailus * Search for a property in a device tree node and retrieve a null 3871df09bc6SSakari Ailus * terminated string value (pointer to data, not a copy). Returns 0 on 3881df09bc6SSakari Ailus * success, -EINVAL if the property does not exist, -ENODATA if property 3891df09bc6SSakari Ailus * does not have a value, and -EILSEQ if the string is not null-terminated 3901df09bc6SSakari Ailus * within the length of the property data. 3911df09bc6SSakari Ailus * 3921df09bc6SSakari Ailus * The out_string pointer is modified only if a valid string can be decoded. 3931df09bc6SSakari Ailus */ 3941df09bc6SSakari Ailus int of_property_read_string(const struct device_node *np, const char *propname, 3951df09bc6SSakari Ailus const char **out_string) 3961df09bc6SSakari Ailus { 3971df09bc6SSakari Ailus const struct property *prop = of_find_property(np, propname, NULL); 3981df09bc6SSakari Ailus if (!prop) 3991df09bc6SSakari Ailus return -EINVAL; 4001df09bc6SSakari Ailus if (!prop->value) 4011df09bc6SSakari Ailus return -ENODATA; 4021df09bc6SSakari Ailus if (strnlen(prop->value, prop->length) >= prop->length) 4031df09bc6SSakari Ailus return -EILSEQ; 4041df09bc6SSakari Ailus *out_string = prop->value; 4051df09bc6SSakari Ailus return 0; 4061df09bc6SSakari Ailus } 4071df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_string); 4081df09bc6SSakari Ailus 4091df09bc6SSakari Ailus /** 4101df09bc6SSakari Ailus * of_property_match_string() - Find string in a list and return index 4111df09bc6SSakari Ailus * @np: pointer to node containing string list property 4121df09bc6SSakari Ailus * @propname: string list property name 4131df09bc6SSakari Ailus * @string: pointer to string to search for in string list 4141df09bc6SSakari Ailus * 4151df09bc6SSakari Ailus * This function searches a string list property and returns the index 4161df09bc6SSakari Ailus * of a specific string value. 4171df09bc6SSakari Ailus */ 4181df09bc6SSakari Ailus int of_property_match_string(const struct device_node *np, const char *propname, 4191df09bc6SSakari Ailus const char *string) 4201df09bc6SSakari Ailus { 4211df09bc6SSakari Ailus const struct property *prop = of_find_property(np, propname, NULL); 4221df09bc6SSakari Ailus size_t l; 4231df09bc6SSakari Ailus int i; 4241df09bc6SSakari Ailus const char *p, *end; 4251df09bc6SSakari Ailus 4261df09bc6SSakari Ailus if (!prop) 4271df09bc6SSakari Ailus return -EINVAL; 4281df09bc6SSakari Ailus if (!prop->value) 4291df09bc6SSakari Ailus return -ENODATA; 4301df09bc6SSakari Ailus 4311df09bc6SSakari Ailus p = prop->value; 4321df09bc6SSakari Ailus end = p + prop->length; 4331df09bc6SSakari Ailus 4341df09bc6SSakari Ailus for (i = 0; p < end; i++, p += l) { 4351df09bc6SSakari Ailus l = strnlen(p, end - p) + 1; 4361df09bc6SSakari Ailus if (p + l > end) 4371df09bc6SSakari Ailus return -EILSEQ; 4381df09bc6SSakari Ailus pr_debug("comparing %s with %s\n", string, p); 4391df09bc6SSakari Ailus if (strcmp(string, p) == 0) 4401df09bc6SSakari Ailus return i; /* Found it; return index */ 4411df09bc6SSakari Ailus } 4421df09bc6SSakari Ailus return -ENODATA; 4431df09bc6SSakari Ailus } 4441df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_match_string); 4451df09bc6SSakari Ailus 4461df09bc6SSakari Ailus /** 4471df09bc6SSakari Ailus * of_property_read_string_helper() - Utility helper for parsing string properties 4481df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 4491df09bc6SSakari Ailus * @propname: name of the property to be searched. 4501df09bc6SSakari Ailus * @out_strs: output array of string pointers. 4511df09bc6SSakari Ailus * @sz: number of array elements to read. 4521df09bc6SSakari Ailus * @skip: Number of strings to skip over at beginning of list. 4531df09bc6SSakari Ailus * 4541df09bc6SSakari Ailus * Don't call this function directly. It is a utility helper for the 4551df09bc6SSakari Ailus * of_property_read_string*() family of functions. 4561df09bc6SSakari Ailus */ 4571df09bc6SSakari Ailus int of_property_read_string_helper(const struct device_node *np, 4581df09bc6SSakari Ailus const char *propname, const char **out_strs, 4591df09bc6SSakari Ailus size_t sz, int skip) 4601df09bc6SSakari Ailus { 4611df09bc6SSakari Ailus const struct property *prop = of_find_property(np, propname, NULL); 4621df09bc6SSakari Ailus int l = 0, i = 0; 4631df09bc6SSakari Ailus const char *p, *end; 4641df09bc6SSakari Ailus 4651df09bc6SSakari Ailus if (!prop) 4661df09bc6SSakari Ailus return -EINVAL; 4671df09bc6SSakari Ailus if (!prop->value) 4681df09bc6SSakari Ailus return -ENODATA; 4691df09bc6SSakari Ailus p = prop->value; 4701df09bc6SSakari Ailus end = p + prop->length; 4711df09bc6SSakari Ailus 4721df09bc6SSakari Ailus for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) { 4731df09bc6SSakari Ailus l = strnlen(p, end - p) + 1; 4741df09bc6SSakari Ailus if (p + l > end) 4751df09bc6SSakari Ailus return -EILSEQ; 4761df09bc6SSakari Ailus if (out_strs && i >= skip) 4771df09bc6SSakari Ailus *out_strs++ = p; 4781df09bc6SSakari Ailus } 4791df09bc6SSakari Ailus i -= skip; 4801df09bc6SSakari Ailus return i <= 0 ? -ENODATA : i; 4811df09bc6SSakari Ailus } 4821df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_string_helper); 4831df09bc6SSakari Ailus 4841df09bc6SSakari Ailus const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 4851df09bc6SSakari Ailus u32 *pu) 4861df09bc6SSakari Ailus { 4871df09bc6SSakari Ailus const void *curv = cur; 4881df09bc6SSakari Ailus 4891df09bc6SSakari Ailus if (!prop) 4901df09bc6SSakari Ailus return NULL; 4911df09bc6SSakari Ailus 4921df09bc6SSakari Ailus if (!cur) { 4931df09bc6SSakari Ailus curv = prop->value; 4941df09bc6SSakari Ailus goto out_val; 4951df09bc6SSakari Ailus } 4961df09bc6SSakari Ailus 4971df09bc6SSakari Ailus curv += sizeof(*cur); 4981df09bc6SSakari Ailus if (curv >= prop->value + prop->length) 4991df09bc6SSakari Ailus return NULL; 5001df09bc6SSakari Ailus 5011df09bc6SSakari Ailus out_val: 5021df09bc6SSakari Ailus *pu = be32_to_cpup(curv); 5031df09bc6SSakari Ailus return curv; 5041df09bc6SSakari Ailus } 5051df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_prop_next_u32); 5061df09bc6SSakari Ailus 5071df09bc6SSakari Ailus const char *of_prop_next_string(struct property *prop, const char *cur) 5081df09bc6SSakari Ailus { 5091df09bc6SSakari Ailus const void *curv = cur; 5101df09bc6SSakari Ailus 5111df09bc6SSakari Ailus if (!prop) 5121df09bc6SSakari Ailus return NULL; 5131df09bc6SSakari Ailus 5141df09bc6SSakari Ailus if (!cur) 5151df09bc6SSakari Ailus return prop->value; 5161df09bc6SSakari Ailus 5171df09bc6SSakari Ailus curv += strlen(cur) + 1; 5181df09bc6SSakari Ailus if (curv >= prop->value + prop->length) 5191df09bc6SSakari Ailus return NULL; 5201df09bc6SSakari Ailus 5211df09bc6SSakari Ailus return curv; 5221df09bc6SSakari Ailus } 5231df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_prop_next_string); 5241df09bc6SSakari Ailus 5251df09bc6SSakari Ailus /** 5261df09bc6SSakari Ailus * of_graph_parse_endpoint() - parse common endpoint node properties 5271df09bc6SSakari Ailus * @node: pointer to endpoint device_node 5281df09bc6SSakari Ailus * @endpoint: pointer to the OF endpoint data structure 5291df09bc6SSakari Ailus * 5301df09bc6SSakari Ailus * The caller should hold a reference to @node. 5311df09bc6SSakari Ailus */ 5321df09bc6SSakari Ailus int of_graph_parse_endpoint(const struct device_node *node, 5331df09bc6SSakari Ailus struct of_endpoint *endpoint) 5341df09bc6SSakari Ailus { 5351df09bc6SSakari Ailus struct device_node *port_node = of_get_parent(node); 5361df09bc6SSakari Ailus 5370d638a07SRob Herring WARN_ONCE(!port_node, "%s(): endpoint %pOF has no parent node\n", 5380d638a07SRob Herring __func__, node); 5391df09bc6SSakari Ailus 5401df09bc6SSakari Ailus memset(endpoint, 0, sizeof(*endpoint)); 5411df09bc6SSakari Ailus 5421df09bc6SSakari Ailus endpoint->local_node = node; 5431df09bc6SSakari Ailus /* 5441df09bc6SSakari Ailus * It doesn't matter whether the two calls below succeed. 5451df09bc6SSakari Ailus * If they don't then the default value 0 is used. 5461df09bc6SSakari Ailus */ 5471df09bc6SSakari Ailus of_property_read_u32(port_node, "reg", &endpoint->port); 5481df09bc6SSakari Ailus of_property_read_u32(node, "reg", &endpoint->id); 5491df09bc6SSakari Ailus 5501df09bc6SSakari Ailus of_node_put(port_node); 5511df09bc6SSakari Ailus 5521df09bc6SSakari Ailus return 0; 5531df09bc6SSakari Ailus } 5541df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_parse_endpoint); 5551df09bc6SSakari Ailus 5561df09bc6SSakari Ailus /** 5571df09bc6SSakari Ailus * of_graph_get_port_by_id() - get the port matching a given id 5581df09bc6SSakari Ailus * @parent: pointer to the parent device node 5591df09bc6SSakari Ailus * @id: id of the port 5601df09bc6SSakari Ailus * 5611df09bc6SSakari Ailus * Return: A 'port' node pointer with refcount incremented. The caller 5621df09bc6SSakari Ailus * has to use of_node_put() on it when done. 5631df09bc6SSakari Ailus */ 5641df09bc6SSakari Ailus struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id) 5651df09bc6SSakari Ailus { 5661df09bc6SSakari Ailus struct device_node *node, *port; 5671df09bc6SSakari Ailus 5681df09bc6SSakari Ailus node = of_get_child_by_name(parent, "ports"); 5691df09bc6SSakari Ailus if (node) 5701df09bc6SSakari Ailus parent = node; 5711df09bc6SSakari Ailus 5721df09bc6SSakari Ailus for_each_child_of_node(parent, port) { 5731df09bc6SSakari Ailus u32 port_id = 0; 5741df09bc6SSakari Ailus 575b3e46d1aSRob Herring if (!of_node_name_eq(port, "port")) 5761df09bc6SSakari Ailus continue; 5771df09bc6SSakari Ailus of_property_read_u32(port, "reg", &port_id); 5781df09bc6SSakari Ailus if (id == port_id) 5791df09bc6SSakari Ailus break; 5801df09bc6SSakari Ailus } 5811df09bc6SSakari Ailus 5821df09bc6SSakari Ailus of_node_put(node); 5831df09bc6SSakari Ailus 5841df09bc6SSakari Ailus return port; 5851df09bc6SSakari Ailus } 5861df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_port_by_id); 5871df09bc6SSakari Ailus 5881df09bc6SSakari Ailus /** 5891df09bc6SSakari Ailus * of_graph_get_next_endpoint() - get next endpoint node 5901df09bc6SSakari Ailus * @parent: pointer to the parent device node 5911df09bc6SSakari Ailus * @prev: previous endpoint node, or NULL to get first 5921df09bc6SSakari Ailus * 5931df09bc6SSakari Ailus * Return: An 'endpoint' node pointer with refcount incremented. Refcount 5941df09bc6SSakari Ailus * of the passed @prev node is decremented. 5951df09bc6SSakari Ailus */ 5961df09bc6SSakari Ailus struct device_node *of_graph_get_next_endpoint(const struct device_node *parent, 5971df09bc6SSakari Ailus struct device_node *prev) 5981df09bc6SSakari Ailus { 5991df09bc6SSakari Ailus struct device_node *endpoint; 6001df09bc6SSakari Ailus struct device_node *port; 6011df09bc6SSakari Ailus 6021df09bc6SSakari Ailus if (!parent) 6031df09bc6SSakari Ailus return NULL; 6041df09bc6SSakari Ailus 6051df09bc6SSakari Ailus /* 6061df09bc6SSakari Ailus * Start by locating the port node. If no previous endpoint is specified 6071df09bc6SSakari Ailus * search for the first port node, otherwise get the previous endpoint 6081df09bc6SSakari Ailus * parent port node. 6091df09bc6SSakari Ailus */ 6101df09bc6SSakari Ailus if (!prev) { 6111df09bc6SSakari Ailus struct device_node *node; 6121df09bc6SSakari Ailus 6131df09bc6SSakari Ailus node = of_get_child_by_name(parent, "ports"); 6141df09bc6SSakari Ailus if (node) 6151df09bc6SSakari Ailus parent = node; 6161df09bc6SSakari Ailus 6171df09bc6SSakari Ailus port = of_get_child_by_name(parent, "port"); 6181df09bc6SSakari Ailus of_node_put(node); 6191df09bc6SSakari Ailus 6201df09bc6SSakari Ailus if (!port) { 6210d638a07SRob Herring pr_err("graph: no port node found in %pOF\n", parent); 6221df09bc6SSakari Ailus return NULL; 6231df09bc6SSakari Ailus } 6241df09bc6SSakari Ailus } else { 6251df09bc6SSakari Ailus port = of_get_parent(prev); 6260d638a07SRob Herring if (WARN_ONCE(!port, "%s(): endpoint %pOF has no parent node\n", 6270d638a07SRob Herring __func__, prev)) 6281df09bc6SSakari Ailus return NULL; 6291df09bc6SSakari Ailus } 6301df09bc6SSakari Ailus 6311df09bc6SSakari Ailus while (1) { 6321df09bc6SSakari Ailus /* 6331df09bc6SSakari Ailus * Now that we have a port node, get the next endpoint by 6341df09bc6SSakari Ailus * getting the next child. If the previous endpoint is NULL this 6351df09bc6SSakari Ailus * will return the first child. 6361df09bc6SSakari Ailus */ 6371df09bc6SSakari Ailus endpoint = of_get_next_child(port, prev); 6381df09bc6SSakari Ailus if (endpoint) { 6391df09bc6SSakari Ailus of_node_put(port); 6401df09bc6SSakari Ailus return endpoint; 6411df09bc6SSakari Ailus } 6421df09bc6SSakari Ailus 6431df09bc6SSakari Ailus /* No more endpoints under this port, try the next one. */ 6441df09bc6SSakari Ailus prev = NULL; 6451df09bc6SSakari Ailus 6461df09bc6SSakari Ailus do { 6471df09bc6SSakari Ailus port = of_get_next_child(parent, port); 6481df09bc6SSakari Ailus if (!port) 6491df09bc6SSakari Ailus return NULL; 650b3e46d1aSRob Herring } while (!of_node_name_eq(port, "port")); 6511df09bc6SSakari Ailus } 6521df09bc6SSakari Ailus } 6531df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_next_endpoint); 6541df09bc6SSakari Ailus 6551df09bc6SSakari Ailus /** 6561df09bc6SSakari Ailus * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers 6571df09bc6SSakari Ailus * @parent: pointer to the parent device node 6581df09bc6SSakari Ailus * @port_reg: identifier (value of reg property) of the parent port node 6591df09bc6SSakari Ailus * @reg: identifier (value of reg property) of the endpoint node 6601df09bc6SSakari Ailus * 6611df09bc6SSakari Ailus * Return: An 'endpoint' node pointer which is identified by reg and at the same 6621df09bc6SSakari Ailus * is the child of a port node identified by port_reg. reg and port_reg are 663deb387d4SMaxime Ripard * ignored when they are -1. Use of_node_put() on the pointer when done. 6641df09bc6SSakari Ailus */ 6651df09bc6SSakari Ailus struct device_node *of_graph_get_endpoint_by_regs( 6661df09bc6SSakari Ailus const struct device_node *parent, int port_reg, int reg) 6671df09bc6SSakari Ailus { 6681df09bc6SSakari Ailus struct of_endpoint endpoint; 6691df09bc6SSakari Ailus struct device_node *node = NULL; 6701df09bc6SSakari Ailus 6711df09bc6SSakari Ailus for_each_endpoint_of_node(parent, node) { 6721df09bc6SSakari Ailus of_graph_parse_endpoint(node, &endpoint); 6731df09bc6SSakari Ailus if (((port_reg == -1) || (endpoint.port == port_reg)) && 6741df09bc6SSakari Ailus ((reg == -1) || (endpoint.id == reg))) 6751df09bc6SSakari Ailus return node; 6761df09bc6SSakari Ailus } 6771df09bc6SSakari Ailus 6781df09bc6SSakari Ailus return NULL; 6791df09bc6SSakari Ailus } 6801df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_endpoint_by_regs); 6811df09bc6SSakari Ailus 6821df09bc6SSakari Ailus /** 683b8ba92b1SRob Herring * of_graph_get_remote_endpoint() - get remote endpoint node 684b8ba92b1SRob Herring * @node: pointer to a local endpoint device_node 685b8ba92b1SRob Herring * 686b8ba92b1SRob Herring * Return: Remote endpoint node associated with remote endpoint node linked 687b8ba92b1SRob Herring * to @node. Use of_node_put() on it when done. 688b8ba92b1SRob Herring */ 689b8ba92b1SRob Herring struct device_node *of_graph_get_remote_endpoint(const struct device_node *node) 690b8ba92b1SRob Herring { 691b8ba92b1SRob Herring /* Get remote endpoint node. */ 692b8ba92b1SRob Herring return of_parse_phandle(node, "remote-endpoint", 0); 693b8ba92b1SRob Herring } 694b8ba92b1SRob Herring EXPORT_SYMBOL(of_graph_get_remote_endpoint); 695b8ba92b1SRob Herring 696b8ba92b1SRob Herring /** 697b8ba92b1SRob Herring * of_graph_get_port_parent() - get port's parent node 698b8ba92b1SRob Herring * @node: pointer to a local endpoint device_node 699b8ba92b1SRob Herring * 700b8ba92b1SRob Herring * Return: device node associated with endpoint node linked 701b8ba92b1SRob Herring * to @node. Use of_node_put() on it when done. 702b8ba92b1SRob Herring */ 703b8ba92b1SRob Herring struct device_node *of_graph_get_port_parent(struct device_node *node) 704b8ba92b1SRob Herring { 705b8ba92b1SRob Herring unsigned int depth; 706b8ba92b1SRob Herring 707c0a480d1STony Lindgren if (!node) 708c0a480d1STony Lindgren return NULL; 709c0a480d1STony Lindgren 710c0a480d1STony Lindgren /* 711c0a480d1STony Lindgren * Preserve usecount for passed in node as of_get_next_parent() 712c0a480d1STony Lindgren * will do of_node_put() on it. 713c0a480d1STony Lindgren */ 714c0a480d1STony Lindgren of_node_get(node); 715c0a480d1STony Lindgren 716b8ba92b1SRob Herring /* Walk 3 levels up only if there is 'ports' node. */ 717b8ba92b1SRob Herring for (depth = 3; depth && node; depth--) { 718b8ba92b1SRob Herring node = of_get_next_parent(node); 719b3e46d1aSRob Herring if (depth == 2 && !of_node_name_eq(node, "ports")) 720b8ba92b1SRob Herring break; 721b8ba92b1SRob Herring } 722b8ba92b1SRob Herring return node; 723b8ba92b1SRob Herring } 724b8ba92b1SRob Herring EXPORT_SYMBOL(of_graph_get_port_parent); 725b8ba92b1SRob Herring 726b8ba92b1SRob Herring /** 7271df09bc6SSakari Ailus * of_graph_get_remote_port_parent() - get remote port's parent node 7281df09bc6SSakari Ailus * @node: pointer to a local endpoint device_node 7291df09bc6SSakari Ailus * 7301df09bc6SSakari Ailus * Return: Remote device node associated with remote endpoint node linked 7311df09bc6SSakari Ailus * to @node. Use of_node_put() on it when done. 7321df09bc6SSakari Ailus */ 7331df09bc6SSakari Ailus struct device_node *of_graph_get_remote_port_parent( 7341df09bc6SSakari Ailus const struct device_node *node) 7351df09bc6SSakari Ailus { 736c0a480d1STony Lindgren struct device_node *np, *pp; 7371df09bc6SSakari Ailus 7381df09bc6SSakari Ailus /* Get remote endpoint node. */ 739b8ba92b1SRob Herring np = of_graph_get_remote_endpoint(node); 7401df09bc6SSakari Ailus 741c0a480d1STony Lindgren pp = of_graph_get_port_parent(np); 742c0a480d1STony Lindgren 743c0a480d1STony Lindgren of_node_put(np); 744c0a480d1STony Lindgren 745c0a480d1STony Lindgren return pp; 7461df09bc6SSakari Ailus } 7471df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_remote_port_parent); 7481df09bc6SSakari Ailus 7491df09bc6SSakari Ailus /** 7501df09bc6SSakari Ailus * of_graph_get_remote_port() - get remote port node 7511df09bc6SSakari Ailus * @node: pointer to a local endpoint device_node 7521df09bc6SSakari Ailus * 7531df09bc6SSakari Ailus * Return: Remote port node associated with remote endpoint node linked 7541df09bc6SSakari Ailus * to @node. Use of_node_put() on it when done. 7551df09bc6SSakari Ailus */ 7561df09bc6SSakari Ailus struct device_node *of_graph_get_remote_port(const struct device_node *node) 7571df09bc6SSakari Ailus { 7581df09bc6SSakari Ailus struct device_node *np; 7591df09bc6SSakari Ailus 7601df09bc6SSakari Ailus /* Get remote endpoint node. */ 761b8ba92b1SRob Herring np = of_graph_get_remote_endpoint(node); 7621df09bc6SSakari Ailus if (!np) 7631df09bc6SSakari Ailus return NULL; 7641df09bc6SSakari Ailus return of_get_next_parent(np); 7651df09bc6SSakari Ailus } 7661df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_remote_port); 7671df09bc6SSakari Ailus 768b8ba92b1SRob Herring int of_graph_get_endpoint_count(const struct device_node *np) 769b8ba92b1SRob Herring { 770b8ba92b1SRob Herring struct device_node *endpoint; 771b8ba92b1SRob Herring int num = 0; 772b8ba92b1SRob Herring 773b8ba92b1SRob Herring for_each_endpoint_of_node(np, endpoint) 774b8ba92b1SRob Herring num++; 775b8ba92b1SRob Herring 776b8ba92b1SRob Herring return num; 777b8ba92b1SRob Herring } 778b8ba92b1SRob Herring EXPORT_SYMBOL(of_graph_get_endpoint_count); 779b8ba92b1SRob Herring 7801df09bc6SSakari Ailus /** 7811df09bc6SSakari Ailus * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint 7821df09bc6SSakari Ailus * @node: pointer to parent device_node containing graph port/endpoint 7831df09bc6SSakari Ailus * @port: identifier (value of reg property) of the parent port node 7841df09bc6SSakari Ailus * @endpoint: identifier (value of reg property) of the endpoint node 7851df09bc6SSakari Ailus * 7861df09bc6SSakari Ailus * Return: Remote device node associated with remote endpoint node linked 7871df09bc6SSakari Ailus * to @node. Use of_node_put() on it when done. 7881df09bc6SSakari Ailus */ 7891df09bc6SSakari Ailus struct device_node *of_graph_get_remote_node(const struct device_node *node, 7901df09bc6SSakari Ailus u32 port, u32 endpoint) 7911df09bc6SSakari Ailus { 7921df09bc6SSakari Ailus struct device_node *endpoint_node, *remote; 7931df09bc6SSakari Ailus 7941df09bc6SSakari Ailus endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint); 7951df09bc6SSakari Ailus if (!endpoint_node) { 7960d638a07SRob Herring pr_debug("no valid endpoint (%d, %d) for node %pOF\n", 7970d638a07SRob Herring port, endpoint, node); 7981df09bc6SSakari Ailus return NULL; 7991df09bc6SSakari Ailus } 8001df09bc6SSakari Ailus 8011df09bc6SSakari Ailus remote = of_graph_get_remote_port_parent(endpoint_node); 8021df09bc6SSakari Ailus of_node_put(endpoint_node); 8031df09bc6SSakari Ailus if (!remote) { 8041df09bc6SSakari Ailus pr_debug("no valid remote node\n"); 8051df09bc6SSakari Ailus return NULL; 8061df09bc6SSakari Ailus } 8071df09bc6SSakari Ailus 8081df09bc6SSakari Ailus if (!of_device_is_available(remote)) { 8091df09bc6SSakari Ailus pr_debug("not available for remote node\n"); 81028b170e8SJulia Lawall of_node_put(remote); 8111df09bc6SSakari Ailus return NULL; 8121df09bc6SSakari Ailus } 8131df09bc6SSakari Ailus 8141df09bc6SSakari Ailus return remote; 8151df09bc6SSakari Ailus } 8161df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_remote_node); 8173708184aSSakari Ailus 818cf89a31cSSakari Ailus static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode) 8193708184aSSakari Ailus { 820cf89a31cSSakari Ailus return of_fwnode_handle(of_node_get(to_of_node(fwnode))); 8213708184aSSakari Ailus } 8223708184aSSakari Ailus 8233708184aSSakari Ailus static void of_fwnode_put(struct fwnode_handle *fwnode) 8243708184aSSakari Ailus { 8253708184aSSakari Ailus of_node_put(to_of_node(fwnode)); 8263708184aSSakari Ailus } 8273708184aSSakari Ailus 82837ba983cSSakari Ailus static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode) 8292294b3afSSakari Ailus { 8302294b3afSSakari Ailus return of_device_is_available(to_of_node(fwnode)); 8312294b3afSSakari Ailus } 8322294b3afSSakari Ailus 83337ba983cSSakari Ailus static bool of_fwnode_property_present(const struct fwnode_handle *fwnode, 8343708184aSSakari Ailus const char *propname) 8353708184aSSakari Ailus { 8363708184aSSakari Ailus return of_property_read_bool(to_of_node(fwnode), propname); 8373708184aSSakari Ailus } 8383708184aSSakari Ailus 83937ba983cSSakari Ailus static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode, 8403708184aSSakari Ailus const char *propname, 8413708184aSSakari Ailus unsigned int elem_size, void *val, 8423708184aSSakari Ailus size_t nval) 8433708184aSSakari Ailus { 84437ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 8453708184aSSakari Ailus 8463708184aSSakari Ailus if (!val) 8473708184aSSakari Ailus return of_property_count_elems_of_size(node, propname, 8483708184aSSakari Ailus elem_size); 8493708184aSSakari Ailus 8503708184aSSakari Ailus switch (elem_size) { 8513708184aSSakari Ailus case sizeof(u8): 8523708184aSSakari Ailus return of_property_read_u8_array(node, propname, val, nval); 8533708184aSSakari Ailus case sizeof(u16): 8543708184aSSakari Ailus return of_property_read_u16_array(node, propname, val, nval); 8553708184aSSakari Ailus case sizeof(u32): 8563708184aSSakari Ailus return of_property_read_u32_array(node, propname, val, nval); 8573708184aSSakari Ailus case sizeof(u64): 8583708184aSSakari Ailus return of_property_read_u64_array(node, propname, val, nval); 8593708184aSSakari Ailus } 8603708184aSSakari Ailus 8613708184aSSakari Ailus return -ENXIO; 8623708184aSSakari Ailus } 8633708184aSSakari Ailus 86437ba983cSSakari Ailus static int 86537ba983cSSakari Ailus of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode, 86637ba983cSSakari Ailus const char *propname, const char **val, 86737ba983cSSakari Ailus size_t nval) 8683708184aSSakari Ailus { 86937ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 8703708184aSSakari Ailus 8713708184aSSakari Ailus return val ? 8723708184aSSakari Ailus of_property_read_string_array(node, propname, val, nval) : 8733708184aSSakari Ailus of_property_count_strings(node, propname); 8743708184aSSakari Ailus } 8753708184aSSakari Ailus 87637ba983cSSakari Ailus static struct fwnode_handle * 87737ba983cSSakari Ailus of_fwnode_get_parent(const struct fwnode_handle *fwnode) 8783708184aSSakari Ailus { 8793708184aSSakari Ailus return of_fwnode_handle(of_get_parent(to_of_node(fwnode))); 8803708184aSSakari Ailus } 8813708184aSSakari Ailus 8823708184aSSakari Ailus static struct fwnode_handle * 88337ba983cSSakari Ailus of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode, 8843708184aSSakari Ailus struct fwnode_handle *child) 8853708184aSSakari Ailus { 8863708184aSSakari Ailus return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode), 8873708184aSSakari Ailus to_of_node(child))); 8883708184aSSakari Ailus } 8893708184aSSakari Ailus 8903708184aSSakari Ailus static struct fwnode_handle * 89137ba983cSSakari Ailus of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode, 8923708184aSSakari Ailus const char *childname) 8933708184aSSakari Ailus { 89437ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 8953708184aSSakari Ailus struct device_node *child; 8963708184aSSakari Ailus 8973708184aSSakari Ailus for_each_available_child_of_node(node, child) 898b3e46d1aSRob Herring if (of_node_name_eq(child, childname)) 8993708184aSSakari Ailus return of_fwnode_handle(child); 9003708184aSSakari Ailus 9013708184aSSakari Ailus return NULL; 9023708184aSSakari Ailus } 9033708184aSSakari Ailus 9043e3119d3SSakari Ailus static int 9053e3119d3SSakari Ailus of_fwnode_get_reference_args(const struct fwnode_handle *fwnode, 9063e3119d3SSakari Ailus const char *prop, const char *nargs_prop, 9073e3119d3SSakari Ailus unsigned int nargs, unsigned int index, 9083e3119d3SSakari Ailus struct fwnode_reference_args *args) 9093e3119d3SSakari Ailus { 9103e3119d3SSakari Ailus struct of_phandle_args of_args; 9113e3119d3SSakari Ailus unsigned int i; 9123e3119d3SSakari Ailus int ret; 9133e3119d3SSakari Ailus 9143e3119d3SSakari Ailus if (nargs_prop) 9153e3119d3SSakari Ailus ret = of_parse_phandle_with_args(to_of_node(fwnode), prop, 9163e3119d3SSakari Ailus nargs_prop, index, &of_args); 9173e3119d3SSakari Ailus else 9183e3119d3SSakari Ailus ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop, 9193e3119d3SSakari Ailus nargs, index, &of_args); 9203e3119d3SSakari Ailus if (ret < 0) 9213e3119d3SSakari Ailus return ret; 9223e3119d3SSakari Ailus if (!args) 9233e3119d3SSakari Ailus return 0; 9243e3119d3SSakari Ailus 9253e3119d3SSakari Ailus args->nargs = of_args.args_count; 9263e3119d3SSakari Ailus args->fwnode = of_fwnode_handle(of_args.np); 9273e3119d3SSakari Ailus 9283e3119d3SSakari Ailus for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++) 9293e3119d3SSakari Ailus args->args[i] = i < of_args.args_count ? of_args.args[i] : 0; 9303e3119d3SSakari Ailus 9313e3119d3SSakari Ailus return 0; 9323e3119d3SSakari Ailus } 9333e3119d3SSakari Ailus 9343b27d00eSSakari Ailus static struct fwnode_handle * 93537ba983cSSakari Ailus of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode, 9363b27d00eSSakari Ailus struct fwnode_handle *prev) 9373b27d00eSSakari Ailus { 9383b27d00eSSakari Ailus return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode), 9393b27d00eSSakari Ailus to_of_node(prev))); 9403b27d00eSSakari Ailus } 9413b27d00eSSakari Ailus 9423b27d00eSSakari Ailus static struct fwnode_handle * 94337ba983cSSakari Ailus of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode) 9443b27d00eSSakari Ailus { 945358155edSKuninori Morimoto return of_fwnode_handle( 946358155edSKuninori Morimoto of_graph_get_remote_endpoint(to_of_node(fwnode))); 9473b27d00eSSakari Ailus } 9483b27d00eSSakari Ailus 9493b27d00eSSakari Ailus static struct fwnode_handle * 9503b27d00eSSakari Ailus of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode) 9513b27d00eSSakari Ailus { 9523b27d00eSSakari Ailus struct device_node *np; 9533b27d00eSSakari Ailus 9543b27d00eSSakari Ailus /* Get the parent of the port */ 9553314c6bdSNiklas Söderlund np = of_get_parent(to_of_node(fwnode)); 9563b27d00eSSakari Ailus if (!np) 9573b27d00eSSakari Ailus return NULL; 9583b27d00eSSakari Ailus 9593b27d00eSSakari Ailus /* Is this the "ports" node? If not, it's the port parent. */ 960b3e46d1aSRob Herring if (!of_node_name_eq(np, "ports")) 9613b27d00eSSakari Ailus return of_fwnode_handle(np); 9623b27d00eSSakari Ailus 9633b27d00eSSakari Ailus return of_fwnode_handle(of_get_next_parent(np)); 9643b27d00eSSakari Ailus } 9653b27d00eSSakari Ailus 96637ba983cSSakari Ailus static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode, 9673b27d00eSSakari Ailus struct fwnode_endpoint *endpoint) 9683b27d00eSSakari Ailus { 96937ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 9703b27d00eSSakari Ailus struct device_node *port_node = of_get_parent(node); 9713b27d00eSSakari Ailus 9723b27d00eSSakari Ailus endpoint->local_fwnode = fwnode; 9733b27d00eSSakari Ailus 9743b27d00eSSakari Ailus of_property_read_u32(port_node, "reg", &endpoint->port); 9753b27d00eSSakari Ailus of_property_read_u32(node, "reg", &endpoint->id); 9763b27d00eSSakari Ailus 9773b27d00eSSakari Ailus of_node_put(port_node); 9783b27d00eSSakari Ailus 9793b27d00eSSakari Ailus return 0; 9803b27d00eSSakari Ailus } 9813b27d00eSSakari Ailus 98267dcc26dSAndy Shevchenko static const void * 9831c2c82eaSSinan Kaya of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode, 9841c2c82eaSSinan Kaya const struct device *dev) 9851c2c82eaSSinan Kaya { 98667dcc26dSAndy Shevchenko return of_device_get_match_data(dev); 9871c2c82eaSSinan Kaya } 9881c2c82eaSSinan Kaya 989a3e1d1a7SSaravana Kannan static bool of_is_ancestor_of(struct device_node *test_ancestor, 990a3e1d1a7SSaravana Kannan struct device_node *child) 991a3e1d1a7SSaravana Kannan { 992a3e1d1a7SSaravana Kannan of_node_get(child); 993a3e1d1a7SSaravana Kannan while (child) { 994a3e1d1a7SSaravana Kannan if (child == test_ancestor) { 995a3e1d1a7SSaravana Kannan of_node_put(child); 996a3e1d1a7SSaravana Kannan return false; 997a3e1d1a7SSaravana Kannan } 998a3e1d1a7SSaravana Kannan child = of_get_next_parent(child); 999a3e1d1a7SSaravana Kannan } 1000a3e1d1a7SSaravana Kannan return true; 1001a3e1d1a7SSaravana Kannan } 1002a3e1d1a7SSaravana Kannan 1003a3e1d1a7SSaravana Kannan /** 1004a3e1d1a7SSaravana Kannan * of_link_to_phandle - Add device link to supplier from supplier phandle 1005a3e1d1a7SSaravana Kannan * @dev: consumer device 1006a3e1d1a7SSaravana Kannan * @sup_np: phandle to supplier device tree node 1007a3e1d1a7SSaravana Kannan * 1008a3e1d1a7SSaravana Kannan * Given a phandle to a supplier device tree node (@sup_np), this function 1009a3e1d1a7SSaravana Kannan * finds the device that owns the supplier device tree node and creates a 1010a3e1d1a7SSaravana Kannan * device link from @dev consumer device to the supplier device. This function 1011a3e1d1a7SSaravana Kannan * doesn't create device links for invalid scenarios such as trying to create a 1012a3e1d1a7SSaravana Kannan * link with a parent device as the consumer of its child device. In such 1013a3e1d1a7SSaravana Kannan * cases, it returns an error. 1014a3e1d1a7SSaravana Kannan * 1015a3e1d1a7SSaravana Kannan * Returns: 1016a3e1d1a7SSaravana Kannan * - 0 if link successfully created to supplier 1017a3e1d1a7SSaravana Kannan * - -EAGAIN if linking to the supplier should be reattempted 1018a3e1d1a7SSaravana Kannan * - -EINVAL if the supplier link is invalid and should not be created 1019a3e1d1a7SSaravana Kannan * - -ENODEV if there is no device that corresponds to the supplier phandle 1020a3e1d1a7SSaravana Kannan */ 1021a3e1d1a7SSaravana Kannan static int of_link_to_phandle(struct device *dev, struct device_node *sup_np) 1022a3e1d1a7SSaravana Kannan { 1023a3e1d1a7SSaravana Kannan struct device *sup_dev; 1024a3e1d1a7SSaravana Kannan u32 dl_flags = DL_FLAG_AUTOPROBE_CONSUMER; 1025a3e1d1a7SSaravana Kannan int ret = 0; 1026a3e1d1a7SSaravana Kannan struct device_node *tmp_np = sup_np; 1027a3e1d1a7SSaravana Kannan 1028a3e1d1a7SSaravana Kannan of_node_get(sup_np); 1029a3e1d1a7SSaravana Kannan /* 1030a3e1d1a7SSaravana Kannan * Find the device node that contains the supplier phandle. It may be 1031a3e1d1a7SSaravana Kannan * @sup_np or it may be an ancestor of @sup_np. 1032a3e1d1a7SSaravana Kannan */ 1033a3e1d1a7SSaravana Kannan while (sup_np && !of_find_property(sup_np, "compatible", NULL)) 1034a3e1d1a7SSaravana Kannan sup_np = of_get_next_parent(sup_np); 1035a3e1d1a7SSaravana Kannan if (!sup_np) { 1036a3e1d1a7SSaravana Kannan dev_dbg(dev, "Not linking to %pOFP - No device\n", tmp_np); 1037a3e1d1a7SSaravana Kannan return -ENODEV; 1038a3e1d1a7SSaravana Kannan } 1039a3e1d1a7SSaravana Kannan 1040a3e1d1a7SSaravana Kannan /* 1041a3e1d1a7SSaravana Kannan * Don't allow linking a device node as a consumer of one of its 1042a3e1d1a7SSaravana Kannan * descendant nodes. By definition, a child node can't be a functional 1043a3e1d1a7SSaravana Kannan * dependency for the parent node. 1044a3e1d1a7SSaravana Kannan */ 1045a3e1d1a7SSaravana Kannan if (!of_is_ancestor_of(dev->of_node, sup_np)) { 1046a3e1d1a7SSaravana Kannan dev_dbg(dev, "Not linking to %pOFP - is descendant\n", sup_np); 1047a3e1d1a7SSaravana Kannan of_node_put(sup_np); 1048a3e1d1a7SSaravana Kannan return -EINVAL; 1049a3e1d1a7SSaravana Kannan } 1050a3e1d1a7SSaravana Kannan sup_dev = get_dev_from_fwnode(&sup_np->fwnode); 1051a3e1d1a7SSaravana Kannan of_node_put(sup_np); 1052a3e1d1a7SSaravana Kannan if (!sup_dev) 1053a3e1d1a7SSaravana Kannan return -EAGAIN; 1054a3e1d1a7SSaravana Kannan if (!device_link_add(dev, sup_dev, dl_flags)) 1055a3e1d1a7SSaravana Kannan ret = -EAGAIN; 1056a3e1d1a7SSaravana Kannan put_device(sup_dev); 1057a3e1d1a7SSaravana Kannan return ret; 1058a3e1d1a7SSaravana Kannan } 1059a3e1d1a7SSaravana Kannan 1060a3e1d1a7SSaravana Kannan /** 1061a3e1d1a7SSaravana Kannan * parse_prop_cells - Property parsing function for suppliers 1062a3e1d1a7SSaravana Kannan * 1063a3e1d1a7SSaravana Kannan * @np: Pointer to device tree node containing a list 1064a3e1d1a7SSaravana Kannan * @prop_name: Name of property to be parsed. Expected to hold phandle values 1065a3e1d1a7SSaravana Kannan * @index: For properties holding a list of phandles, this is the index 1066a3e1d1a7SSaravana Kannan * into the list. 1067a3e1d1a7SSaravana Kannan * @list_name: Property name that is known to contain list of phandle(s) to 1068a3e1d1a7SSaravana Kannan * supplier(s) 1069a3e1d1a7SSaravana Kannan * @cells_name: property name that specifies phandles' arguments count 1070a3e1d1a7SSaravana Kannan * 1071a3e1d1a7SSaravana Kannan * This is a helper function to parse properties that have a known fixed name 1072a3e1d1a7SSaravana Kannan * and are a list of phandles and phandle arguments. 1073a3e1d1a7SSaravana Kannan * 1074a3e1d1a7SSaravana Kannan * Returns: 1075a3e1d1a7SSaravana Kannan * - phandle node pointer with refcount incremented. Caller must of_node_put() 1076a3e1d1a7SSaravana Kannan * on it when done. 1077a3e1d1a7SSaravana Kannan * - NULL if no phandle found at index 1078a3e1d1a7SSaravana Kannan */ 1079a3e1d1a7SSaravana Kannan static struct device_node *parse_prop_cells(struct device_node *np, 1080a3e1d1a7SSaravana Kannan const char *prop_name, int index, 1081a3e1d1a7SSaravana Kannan const char *list_name, 1082a3e1d1a7SSaravana Kannan const char *cells_name) 1083a3e1d1a7SSaravana Kannan { 1084a3e1d1a7SSaravana Kannan struct of_phandle_args sup_args; 1085a3e1d1a7SSaravana Kannan 1086a3e1d1a7SSaravana Kannan if (strcmp(prop_name, list_name)) 1087a3e1d1a7SSaravana Kannan return NULL; 1088a3e1d1a7SSaravana Kannan 1089a3e1d1a7SSaravana Kannan if (of_parse_phandle_with_args(np, list_name, cells_name, index, 1090a3e1d1a7SSaravana Kannan &sup_args)) 1091a3e1d1a7SSaravana Kannan return NULL; 1092a3e1d1a7SSaravana Kannan 1093a3e1d1a7SSaravana Kannan return sup_args.np; 1094a3e1d1a7SSaravana Kannan } 1095a3e1d1a7SSaravana Kannan 1096a3e1d1a7SSaravana Kannan static struct device_node *parse_clocks(struct device_node *np, 1097a3e1d1a7SSaravana Kannan const char *prop_name, int index) 1098a3e1d1a7SSaravana Kannan { 1099a3e1d1a7SSaravana Kannan return parse_prop_cells(np, prop_name, index, "clocks", "#clock-cells"); 1100a3e1d1a7SSaravana Kannan } 1101a3e1d1a7SSaravana Kannan 1102a3e1d1a7SSaravana Kannan static struct device_node *parse_interconnects(struct device_node *np, 1103a3e1d1a7SSaravana Kannan const char *prop_name, int index) 1104a3e1d1a7SSaravana Kannan { 1105a3e1d1a7SSaravana Kannan return parse_prop_cells(np, prop_name, index, "interconnects", 1106a3e1d1a7SSaravana Kannan "#interconnect-cells"); 1107a3e1d1a7SSaravana Kannan } 1108a3e1d1a7SSaravana Kannan 1109a3e1d1a7SSaravana Kannan static int strcmp_suffix(const char *str, const char *suffix) 1110a3e1d1a7SSaravana Kannan { 1111a3e1d1a7SSaravana Kannan unsigned int len, suffix_len; 1112a3e1d1a7SSaravana Kannan 1113a3e1d1a7SSaravana Kannan len = strlen(str); 1114a3e1d1a7SSaravana Kannan suffix_len = strlen(suffix); 1115a3e1d1a7SSaravana Kannan if (len <= suffix_len) 1116a3e1d1a7SSaravana Kannan return -1; 1117a3e1d1a7SSaravana Kannan return strcmp(str + len - suffix_len, suffix); 1118a3e1d1a7SSaravana Kannan } 1119a3e1d1a7SSaravana Kannan 1120a3e1d1a7SSaravana Kannan static struct device_node *parse_regulators(struct device_node *np, 1121a3e1d1a7SSaravana Kannan const char *prop_name, int index) 1122a3e1d1a7SSaravana Kannan { 1123a3e1d1a7SSaravana Kannan if (index || strcmp_suffix(prop_name, "-supply")) 1124a3e1d1a7SSaravana Kannan return NULL; 1125a3e1d1a7SSaravana Kannan 1126a3e1d1a7SSaravana Kannan return of_parse_phandle(np, prop_name, 0); 1127a3e1d1a7SSaravana Kannan } 1128a3e1d1a7SSaravana Kannan 1129a3e1d1a7SSaravana Kannan /** 1130a3e1d1a7SSaravana Kannan * struct supplier_bindings - Property parsing functions for suppliers 1131a3e1d1a7SSaravana Kannan * 1132a3e1d1a7SSaravana Kannan * @parse_prop: function name 1133a3e1d1a7SSaravana Kannan * parse_prop() finds the node corresponding to a supplier phandle 1134a3e1d1a7SSaravana Kannan * @parse_prop.np: Pointer to device node holding supplier phandle property 1135a3e1d1a7SSaravana Kannan * @parse_prop.prop_name: Name of property holding a phandle value 1136a3e1d1a7SSaravana Kannan * @parse_prop.index: For properties holding a list of phandles, this is the 1137a3e1d1a7SSaravana Kannan * index into the list 1138a3e1d1a7SSaravana Kannan * 1139a3e1d1a7SSaravana Kannan * Returns: 1140a3e1d1a7SSaravana Kannan * parse_prop() return values are 1141a3e1d1a7SSaravana Kannan * - phandle node pointer with refcount incremented. Caller must of_node_put() 1142a3e1d1a7SSaravana Kannan * on it when done. 1143a3e1d1a7SSaravana Kannan * - NULL if no phandle found at index 1144a3e1d1a7SSaravana Kannan */ 1145a3e1d1a7SSaravana Kannan struct supplier_bindings { 1146a3e1d1a7SSaravana Kannan struct device_node *(*parse_prop)(struct device_node *np, 1147a3e1d1a7SSaravana Kannan const char *prop_name, int index); 1148a3e1d1a7SSaravana Kannan }; 1149a3e1d1a7SSaravana Kannan 1150a3e1d1a7SSaravana Kannan static const struct supplier_bindings bindings[] = { 1151a3e1d1a7SSaravana Kannan { .parse_prop = parse_clocks, }, 1152a3e1d1a7SSaravana Kannan { .parse_prop = parse_interconnects, }, 1153a3e1d1a7SSaravana Kannan { .parse_prop = parse_regulators, }, 1154a3e1d1a7SSaravana Kannan {}, 1155a3e1d1a7SSaravana Kannan }; 1156a3e1d1a7SSaravana Kannan 1157a3e1d1a7SSaravana Kannan /** 1158a3e1d1a7SSaravana Kannan * of_link_property - Create device links to suppliers listed in a property 1159a3e1d1a7SSaravana Kannan * @dev: Consumer device 1160a3e1d1a7SSaravana Kannan * @con_np: The consumer device tree node which contains the property 1161a3e1d1a7SSaravana Kannan * @prop_name: Name of property to be parsed 1162a3e1d1a7SSaravana Kannan * 1163a3e1d1a7SSaravana Kannan * This function checks if the property @prop_name that is present in the 1164a3e1d1a7SSaravana Kannan * @con_np device tree node is one of the known common device tree bindings 1165a3e1d1a7SSaravana Kannan * that list phandles to suppliers. If @prop_name isn't one, this function 1166a3e1d1a7SSaravana Kannan * doesn't do anything. 1167a3e1d1a7SSaravana Kannan * 1168a3e1d1a7SSaravana Kannan * If @prop_name is one, this function attempts to create device links from the 1169a3e1d1a7SSaravana Kannan * consumer device @dev to all the devices of the suppliers listed in 1170a3e1d1a7SSaravana Kannan * @prop_name. 1171a3e1d1a7SSaravana Kannan * 1172a3e1d1a7SSaravana Kannan * Any failed attempt to create a device link will NOT result in an immediate 1173a3e1d1a7SSaravana Kannan * return. of_link_property() must create links to all the available supplier 1174a3e1d1a7SSaravana Kannan * devices even when attempts to create a link to one or more suppliers fail. 1175a3e1d1a7SSaravana Kannan */ 1176a3e1d1a7SSaravana Kannan static int of_link_property(struct device *dev, struct device_node *con_np, 1177a3e1d1a7SSaravana Kannan const char *prop_name) 1178a3e1d1a7SSaravana Kannan { 1179a3e1d1a7SSaravana Kannan struct device_node *phandle; 1180a3e1d1a7SSaravana Kannan const struct supplier_bindings *s = bindings; 1181a3e1d1a7SSaravana Kannan unsigned int i = 0; 1182a3e1d1a7SSaravana Kannan bool matched = false; 1183a3e1d1a7SSaravana Kannan int ret = 0; 1184a3e1d1a7SSaravana Kannan 1185a3e1d1a7SSaravana Kannan /* Do not stop at first failed link, link all available suppliers. */ 1186a3e1d1a7SSaravana Kannan while (!matched && s->parse_prop) { 1187a3e1d1a7SSaravana Kannan while ((phandle = s->parse_prop(con_np, prop_name, i))) { 1188a3e1d1a7SSaravana Kannan matched = true; 1189a3e1d1a7SSaravana Kannan i++; 1190a3e1d1a7SSaravana Kannan if (of_link_to_phandle(dev, phandle) == -EAGAIN) 1191a3e1d1a7SSaravana Kannan ret = -EAGAIN; 1192a3e1d1a7SSaravana Kannan of_node_put(phandle); 1193a3e1d1a7SSaravana Kannan } 1194a3e1d1a7SSaravana Kannan s++; 1195a3e1d1a7SSaravana Kannan } 1196a3e1d1a7SSaravana Kannan return ret; 1197a3e1d1a7SSaravana Kannan } 1198a3e1d1a7SSaravana Kannan 1199a3e1d1a7SSaravana Kannan static int __of_link_to_suppliers(struct device *dev, 1200a3e1d1a7SSaravana Kannan struct device_node *con_np) 1201a3e1d1a7SSaravana Kannan { 1202a3e1d1a7SSaravana Kannan struct device_node *child; 1203a3e1d1a7SSaravana Kannan struct property *p; 1204a3e1d1a7SSaravana Kannan int ret = 0; 1205a3e1d1a7SSaravana Kannan 1206a3e1d1a7SSaravana Kannan for_each_property_of_node(con_np, p) 1207a3e1d1a7SSaravana Kannan if (of_link_property(dev, con_np, p->name)) 1208a3e1d1a7SSaravana Kannan ret = -EAGAIN; 1209a3e1d1a7SSaravana Kannan 1210a3e1d1a7SSaravana Kannan return ret; 1211a3e1d1a7SSaravana Kannan } 1212a3e1d1a7SSaravana Kannan 1213a3e1d1a7SSaravana Kannan static bool of_devlink; 1214a3e1d1a7SSaravana Kannan core_param(of_devlink, of_devlink, bool, 0); 1215a3e1d1a7SSaravana Kannan 1216a3e1d1a7SSaravana Kannan static int of_fwnode_add_links(const struct fwnode_handle *fwnode, 1217a3e1d1a7SSaravana Kannan struct device *dev) 1218a3e1d1a7SSaravana Kannan { 1219a3e1d1a7SSaravana Kannan if (!of_devlink) 1220a3e1d1a7SSaravana Kannan return 0; 1221a3e1d1a7SSaravana Kannan 1222a3e1d1a7SSaravana Kannan if (unlikely(!is_of_node(fwnode))) 1223a3e1d1a7SSaravana Kannan return 0; 1224a3e1d1a7SSaravana Kannan 1225a3e1d1a7SSaravana Kannan return __of_link_to_suppliers(dev, to_of_node(fwnode)); 1226a3e1d1a7SSaravana Kannan } 1227a3e1d1a7SSaravana Kannan 12283708184aSSakari Ailus const struct fwnode_operations of_fwnode_ops = { 12293708184aSSakari Ailus .get = of_fwnode_get, 12303708184aSSakari Ailus .put = of_fwnode_put, 12312294b3afSSakari Ailus .device_is_available = of_fwnode_device_is_available, 12321c2c82eaSSinan Kaya .device_get_match_data = of_fwnode_device_get_match_data, 12333708184aSSakari Ailus .property_present = of_fwnode_property_present, 12343708184aSSakari Ailus .property_read_int_array = of_fwnode_property_read_int_array, 12353708184aSSakari Ailus .property_read_string_array = of_fwnode_property_read_string_array, 12363708184aSSakari Ailus .get_parent = of_fwnode_get_parent, 12373708184aSSakari Ailus .get_next_child_node = of_fwnode_get_next_child_node, 12383708184aSSakari Ailus .get_named_child_node = of_fwnode_get_named_child_node, 12393e3119d3SSakari Ailus .get_reference_args = of_fwnode_get_reference_args, 12403b27d00eSSakari Ailus .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint, 12413b27d00eSSakari Ailus .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint, 12423b27d00eSSakari Ailus .graph_get_port_parent = of_fwnode_graph_get_port_parent, 12433b27d00eSSakari Ailus .graph_parse_endpoint = of_fwnode_graph_parse_endpoint, 1244a3e1d1a7SSaravana Kannan .add_links = of_fwnode_add_links, 12453708184aSSakari Ailus }; 1246db3e50f3SSakari Ailus EXPORT_SYMBOL_GPL(of_fwnode_ops); 1247