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> 258c756a0aSSakari Ailus #include <linux/of_address.h> 261df09bc6SSakari Ailus #include <linux/of_device.h> 271df09bc6SSakari Ailus #include <linux/of_graph.h> 284104ca77SSaravana Kannan #include <linux/of_irq.h> 291df09bc6SSakari Ailus #include <linux/string.h> 30a3e1d1a7SSaravana Kannan #include <linux/moduleparam.h> 311df09bc6SSakari Ailus 321df09bc6SSakari Ailus #include "of_private.h" 331df09bc6SSakari Ailus 341df09bc6SSakari Ailus /** 354ec0a44bSDmitry Osipenko * of_graph_is_present() - check graph's presence 364ec0a44bSDmitry Osipenko * @node: pointer to device_node containing graph port 374ec0a44bSDmitry Osipenko * 384ec0a44bSDmitry Osipenko * Return: True if @node has a port or ports (with a port) sub-node, 394ec0a44bSDmitry Osipenko * false otherwise. 404ec0a44bSDmitry Osipenko */ 414ec0a44bSDmitry Osipenko bool of_graph_is_present(const struct device_node *node) 424ec0a44bSDmitry Osipenko { 434ec0a44bSDmitry Osipenko struct device_node *ports, *port; 444ec0a44bSDmitry Osipenko 454ec0a44bSDmitry Osipenko ports = of_get_child_by_name(node, "ports"); 464ec0a44bSDmitry Osipenko if (ports) 474ec0a44bSDmitry Osipenko node = ports; 484ec0a44bSDmitry Osipenko 494ec0a44bSDmitry Osipenko port = of_get_child_by_name(node, "port"); 504ec0a44bSDmitry Osipenko of_node_put(ports); 514ec0a44bSDmitry Osipenko of_node_put(port); 524ec0a44bSDmitry Osipenko 534ec0a44bSDmitry Osipenko return !!port; 544ec0a44bSDmitry Osipenko } 554ec0a44bSDmitry Osipenko EXPORT_SYMBOL(of_graph_is_present); 564ec0a44bSDmitry Osipenko 574ec0a44bSDmitry Osipenko /** 581df09bc6SSakari Ailus * of_property_count_elems_of_size - Count the number of elements in a property 591df09bc6SSakari Ailus * 601df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 611df09bc6SSakari Ailus * @propname: name of the property to be searched. 621df09bc6SSakari Ailus * @elem_size: size of the individual element 631df09bc6SSakari Ailus * 641df09bc6SSakari Ailus * Search for a property in a device node and count the number of elements of 658c8239c2SRob Herring * size elem_size in it. 668c8239c2SRob Herring * 678c8239c2SRob Herring * Return: The number of elements on sucess, -EINVAL if the property does not 688c8239c2SRob Herring * exist or its length does not match a multiple of elem_size and -ENODATA if 698c8239c2SRob Herring * the property does not have a value. 701df09bc6SSakari Ailus */ 711df09bc6SSakari Ailus int of_property_count_elems_of_size(const struct device_node *np, 721df09bc6SSakari Ailus const char *propname, int elem_size) 731df09bc6SSakari Ailus { 741df09bc6SSakari Ailus struct property *prop = of_find_property(np, propname, NULL); 751df09bc6SSakari Ailus 761df09bc6SSakari Ailus if (!prop) 771df09bc6SSakari Ailus return -EINVAL; 781df09bc6SSakari Ailus if (!prop->value) 791df09bc6SSakari Ailus return -ENODATA; 801df09bc6SSakari Ailus 811df09bc6SSakari Ailus if (prop->length % elem_size != 0) { 820d638a07SRob Herring pr_err("size of %s in node %pOF is not a multiple of %d\n", 830d638a07SRob Herring propname, np, elem_size); 841df09bc6SSakari Ailus return -EINVAL; 851df09bc6SSakari Ailus } 861df09bc6SSakari Ailus 871df09bc6SSakari Ailus return prop->length / elem_size; 881df09bc6SSakari Ailus } 891df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_count_elems_of_size); 901df09bc6SSakari Ailus 911df09bc6SSakari Ailus /** 921df09bc6SSakari Ailus * of_find_property_value_of_size 931df09bc6SSakari Ailus * 941df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 951df09bc6SSakari Ailus * @propname: name of the property to be searched. 961df09bc6SSakari Ailus * @min: minimum allowed length of property value 971df09bc6SSakari Ailus * @max: maximum allowed length of property value (0 means unlimited) 981df09bc6SSakari Ailus * @len: if !=NULL, actual length is written to here 991df09bc6SSakari Ailus * 1001df09bc6SSakari Ailus * Search for a property in a device node and valid the requested size. 1018c8239c2SRob Herring * 1028c8239c2SRob Herring * Return: The property value on success, -EINVAL if the property does not 1031df09bc6SSakari Ailus * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the 1041df09bc6SSakari Ailus * property data is too small or too large. 1051df09bc6SSakari Ailus * 1061df09bc6SSakari Ailus */ 1071df09bc6SSakari Ailus static void *of_find_property_value_of_size(const struct device_node *np, 1081df09bc6SSakari Ailus const char *propname, u32 min, u32 max, size_t *len) 1091df09bc6SSakari Ailus { 1101df09bc6SSakari Ailus struct property *prop = of_find_property(np, propname, NULL); 1111df09bc6SSakari Ailus 1121df09bc6SSakari Ailus if (!prop) 1131df09bc6SSakari Ailus return ERR_PTR(-EINVAL); 1141df09bc6SSakari Ailus if (!prop->value) 1151df09bc6SSakari Ailus return ERR_PTR(-ENODATA); 1161df09bc6SSakari Ailus if (prop->length < min) 1171df09bc6SSakari Ailus return ERR_PTR(-EOVERFLOW); 1181df09bc6SSakari Ailus if (max && prop->length > max) 1191df09bc6SSakari Ailus return ERR_PTR(-EOVERFLOW); 1201df09bc6SSakari Ailus 1211df09bc6SSakari Ailus if (len) 1221df09bc6SSakari Ailus *len = prop->length; 1231df09bc6SSakari Ailus 1241df09bc6SSakari Ailus return prop->value; 1251df09bc6SSakari Ailus } 1261df09bc6SSakari Ailus 1271df09bc6SSakari Ailus /** 1281df09bc6SSakari Ailus * of_property_read_u32_index - Find and read a u32 from a multi-value property. 1291df09bc6SSakari Ailus * 1301df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 1311df09bc6SSakari Ailus * @propname: name of the property to be searched. 1321df09bc6SSakari Ailus * @index: index of the u32 in the list of values 1331df09bc6SSakari Ailus * @out_value: pointer to return value, modified only if no error. 1341df09bc6SSakari Ailus * 1351df09bc6SSakari Ailus * Search for a property in a device node and read nth 32-bit value from 1368c8239c2SRob Herring * it. 1378c8239c2SRob Herring * 1388c8239c2SRob Herring * Return: 0 on success, -EINVAL if the property does not exist, 1391df09bc6SSakari Ailus * -ENODATA if property does not have a value, and -EOVERFLOW if the 1401df09bc6SSakari Ailus * property data isn't large enough. 1411df09bc6SSakari Ailus * 1421df09bc6SSakari Ailus * The out_value is modified only if a valid u32 value can be decoded. 1431df09bc6SSakari Ailus */ 1441df09bc6SSakari Ailus int of_property_read_u32_index(const struct device_node *np, 1451df09bc6SSakari Ailus const char *propname, 1461df09bc6SSakari Ailus u32 index, u32 *out_value) 1471df09bc6SSakari Ailus { 1481df09bc6SSakari Ailus const u32 *val = of_find_property_value_of_size(np, propname, 1491df09bc6SSakari Ailus ((index + 1) * sizeof(*out_value)), 1501df09bc6SSakari Ailus 0, 1511df09bc6SSakari Ailus NULL); 1521df09bc6SSakari Ailus 1531df09bc6SSakari Ailus if (IS_ERR(val)) 1541df09bc6SSakari Ailus return PTR_ERR(val); 1551df09bc6SSakari Ailus 1561df09bc6SSakari Ailus *out_value = be32_to_cpup(((__be32 *)val) + index); 1571df09bc6SSakari Ailus return 0; 1581df09bc6SSakari Ailus } 1591df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_u32_index); 1601df09bc6SSakari Ailus 1611df09bc6SSakari Ailus /** 1621df09bc6SSakari Ailus * of_property_read_u64_index - Find and read a u64 from a multi-value property. 1631df09bc6SSakari Ailus * 1641df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 1651df09bc6SSakari Ailus * @propname: name of the property to be searched. 1661df09bc6SSakari Ailus * @index: index of the u64 in the list of values 1671df09bc6SSakari Ailus * @out_value: pointer to return value, modified only if no error. 1681df09bc6SSakari Ailus * 1691df09bc6SSakari Ailus * Search for a property in a device node and read nth 64-bit value from 1708c8239c2SRob Herring * it. 1718c8239c2SRob Herring * 1728c8239c2SRob Herring * Return: 0 on success, -EINVAL if the property does not exist, 1731df09bc6SSakari Ailus * -ENODATA if property does not have a value, and -EOVERFLOW if the 1741df09bc6SSakari Ailus * property data isn't large enough. 1751df09bc6SSakari Ailus * 1761df09bc6SSakari Ailus * The out_value is modified only if a valid u64 value can be decoded. 1771df09bc6SSakari Ailus */ 1781df09bc6SSakari Ailus int of_property_read_u64_index(const struct device_node *np, 1791df09bc6SSakari Ailus const char *propname, 1801df09bc6SSakari Ailus u32 index, u64 *out_value) 1811df09bc6SSakari Ailus { 1821df09bc6SSakari Ailus const u64 *val = of_find_property_value_of_size(np, propname, 1831df09bc6SSakari Ailus ((index + 1) * sizeof(*out_value)), 1841df09bc6SSakari Ailus 0, NULL); 1851df09bc6SSakari Ailus 1861df09bc6SSakari Ailus if (IS_ERR(val)) 1871df09bc6SSakari Ailus return PTR_ERR(val); 1881df09bc6SSakari Ailus 1891df09bc6SSakari Ailus *out_value = be64_to_cpup(((__be64 *)val) + index); 1901df09bc6SSakari Ailus return 0; 1911df09bc6SSakari Ailus } 1921df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_u64_index); 1931df09bc6SSakari Ailus 1941df09bc6SSakari Ailus /** 1951df09bc6SSakari Ailus * of_property_read_variable_u8_array - Find and read an array of u8 from a 1961df09bc6SSakari Ailus * property, with bounds on the minimum and maximum array size. 1971df09bc6SSakari Ailus * 1981df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 1991df09bc6SSakari Ailus * @propname: name of the property to be searched. 2007f3fefeeSMatti Vaittinen * @out_values: pointer to found values. 2011df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 2021df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 2031df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 2041df09bc6SSakari Ailus * sz_min will be read. 2051df09bc6SSakari Ailus * 2061df09bc6SSakari Ailus * Search for a property in a device node and read 8-bit value(s) from 2078c8239c2SRob Herring * it. 2081df09bc6SSakari Ailus * 2091df09bc6SSakari Ailus * dts entry of array should be like: 2108c8239c2SRob Herring * ``property = /bits/ 8 <0x50 0x60 0x70>;`` 2118c8239c2SRob Herring * 2128c8239c2SRob Herring * Return: The number of elements read on success, -EINVAL if the property 2138c8239c2SRob Herring * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 2148c8239c2SRob Herring * if the property data is smaller than sz_min or longer than sz_max. 2151df09bc6SSakari Ailus * 2161df09bc6SSakari Ailus * The out_values is modified only if a valid u8 value can be decoded. 2171df09bc6SSakari Ailus */ 2181df09bc6SSakari Ailus int of_property_read_variable_u8_array(const struct device_node *np, 2191df09bc6SSakari Ailus const char *propname, u8 *out_values, 2201df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 2211df09bc6SSakari Ailus { 2221df09bc6SSakari Ailus size_t sz, count; 2231df09bc6SSakari Ailus const u8 *val = of_find_property_value_of_size(np, propname, 2241df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 2251df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 2261df09bc6SSakari Ailus &sz); 2271df09bc6SSakari Ailus 2281df09bc6SSakari Ailus if (IS_ERR(val)) 2291df09bc6SSakari Ailus return PTR_ERR(val); 2301df09bc6SSakari Ailus 2311df09bc6SSakari Ailus if (!sz_max) 2321df09bc6SSakari Ailus sz = sz_min; 2331df09bc6SSakari Ailus else 2341df09bc6SSakari Ailus sz /= sizeof(*out_values); 2351df09bc6SSakari Ailus 2361df09bc6SSakari Ailus count = sz; 2371df09bc6SSakari Ailus while (count--) 2381df09bc6SSakari Ailus *out_values++ = *val++; 2391df09bc6SSakari Ailus 2401df09bc6SSakari Ailus return sz; 2411df09bc6SSakari Ailus } 2421df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u8_array); 2431df09bc6SSakari Ailus 2441df09bc6SSakari Ailus /** 2451df09bc6SSakari Ailus * of_property_read_variable_u16_array - Find and read an array of u16 from a 2461df09bc6SSakari Ailus * property, with bounds on the minimum and maximum array size. 2471df09bc6SSakari Ailus * 2481df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 2491df09bc6SSakari Ailus * @propname: name of the property to be searched. 2507f3fefeeSMatti Vaittinen * @out_values: pointer to found values. 2511df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 2521df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 2531df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 2541df09bc6SSakari Ailus * sz_min will be read. 2551df09bc6SSakari Ailus * 2561df09bc6SSakari Ailus * Search for a property in a device node and read 16-bit value(s) from 2578c8239c2SRob Herring * it. 2581df09bc6SSakari Ailus * 2591df09bc6SSakari Ailus * dts entry of array should be like: 2608c8239c2SRob Herring * ``property = /bits/ 16 <0x5000 0x6000 0x7000>;`` 2618c8239c2SRob Herring * 2628c8239c2SRob Herring * Return: The number of elements read on success, -EINVAL if the property 2638c8239c2SRob Herring * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 2648c8239c2SRob Herring * if the property data is smaller than sz_min or longer than sz_max. 2651df09bc6SSakari Ailus * 2661df09bc6SSakari Ailus * The out_values is modified only if a valid u16 value can be decoded. 2671df09bc6SSakari Ailus */ 2681df09bc6SSakari Ailus int of_property_read_variable_u16_array(const struct device_node *np, 2691df09bc6SSakari Ailus const char *propname, u16 *out_values, 2701df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 2711df09bc6SSakari Ailus { 2721df09bc6SSakari Ailus size_t sz, count; 2731df09bc6SSakari Ailus const __be16 *val = of_find_property_value_of_size(np, propname, 2741df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 2751df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 2761df09bc6SSakari Ailus &sz); 2771df09bc6SSakari Ailus 2781df09bc6SSakari Ailus if (IS_ERR(val)) 2791df09bc6SSakari Ailus return PTR_ERR(val); 2801df09bc6SSakari Ailus 2811df09bc6SSakari Ailus if (!sz_max) 2821df09bc6SSakari Ailus sz = sz_min; 2831df09bc6SSakari Ailus else 2841df09bc6SSakari Ailus sz /= sizeof(*out_values); 2851df09bc6SSakari Ailus 2861df09bc6SSakari Ailus count = sz; 2871df09bc6SSakari Ailus while (count--) 2881df09bc6SSakari Ailus *out_values++ = be16_to_cpup(val++); 2891df09bc6SSakari Ailus 2901df09bc6SSakari Ailus return sz; 2911df09bc6SSakari Ailus } 2921df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u16_array); 2931df09bc6SSakari Ailus 2941df09bc6SSakari Ailus /** 2951df09bc6SSakari Ailus * of_property_read_variable_u32_array - Find and read an array of 32 bit 2961df09bc6SSakari Ailus * integers from a property, with bounds on the minimum and maximum array size. 2971df09bc6SSakari Ailus * 2981df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 2991df09bc6SSakari Ailus * @propname: name of the property to be searched. 3007f3fefeeSMatti Vaittinen * @out_values: pointer to return found values. 3011df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 3021df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 3031df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 3041df09bc6SSakari Ailus * sz_min will be read. 3051df09bc6SSakari Ailus * 3061df09bc6SSakari Ailus * Search for a property in a device node and read 32-bit value(s) from 3078c8239c2SRob Herring * it. 3088c8239c2SRob Herring * 3098c8239c2SRob Herring * Return: The number of elements read on success, -EINVAL if the property 3101df09bc6SSakari Ailus * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 3111df09bc6SSakari Ailus * if the property data is smaller than sz_min or longer than sz_max. 3121df09bc6SSakari Ailus * 3131df09bc6SSakari Ailus * The out_values is modified only if a valid u32 value can be decoded. 3141df09bc6SSakari Ailus */ 3151df09bc6SSakari Ailus int of_property_read_variable_u32_array(const struct device_node *np, 3161df09bc6SSakari Ailus const char *propname, u32 *out_values, 3171df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 3181df09bc6SSakari Ailus { 3191df09bc6SSakari Ailus size_t sz, count; 3201df09bc6SSakari Ailus const __be32 *val = of_find_property_value_of_size(np, propname, 3211df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 3221df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 3231df09bc6SSakari Ailus &sz); 3241df09bc6SSakari Ailus 3251df09bc6SSakari Ailus if (IS_ERR(val)) 3261df09bc6SSakari Ailus return PTR_ERR(val); 3271df09bc6SSakari Ailus 3281df09bc6SSakari Ailus if (!sz_max) 3291df09bc6SSakari Ailus sz = sz_min; 3301df09bc6SSakari Ailus else 3311df09bc6SSakari Ailus sz /= sizeof(*out_values); 3321df09bc6SSakari Ailus 3331df09bc6SSakari Ailus count = sz; 3341df09bc6SSakari Ailus while (count--) 3351df09bc6SSakari Ailus *out_values++ = be32_to_cpup(val++); 3361df09bc6SSakari Ailus 3371df09bc6SSakari Ailus return sz; 3381df09bc6SSakari Ailus } 3391df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u32_array); 3401df09bc6SSakari Ailus 3411df09bc6SSakari Ailus /** 3421df09bc6SSakari Ailus * of_property_read_u64 - Find and read a 64 bit integer from a property 3431df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 3441df09bc6SSakari Ailus * @propname: name of the property to be searched. 3451df09bc6SSakari Ailus * @out_value: pointer to return value, modified only if return value is 0. 3461df09bc6SSakari Ailus * 3471df09bc6SSakari Ailus * Search for a property in a device node and read a 64-bit value from 3488c8239c2SRob Herring * it. 3498c8239c2SRob Herring * 3508c8239c2SRob Herring * Return: 0 on success, -EINVAL if the property does not exist, 3511df09bc6SSakari Ailus * -ENODATA if property does not have a value, and -EOVERFLOW if the 3521df09bc6SSakari Ailus * property data isn't large enough. 3531df09bc6SSakari Ailus * 3541df09bc6SSakari Ailus * The out_value is modified only if a valid u64 value can be decoded. 3551df09bc6SSakari Ailus */ 3561df09bc6SSakari Ailus int of_property_read_u64(const struct device_node *np, const char *propname, 3571df09bc6SSakari Ailus u64 *out_value) 3581df09bc6SSakari Ailus { 3591df09bc6SSakari Ailus const __be32 *val = of_find_property_value_of_size(np, propname, 3601df09bc6SSakari Ailus sizeof(*out_value), 3611df09bc6SSakari Ailus 0, 3621df09bc6SSakari Ailus NULL); 3631df09bc6SSakari Ailus 3641df09bc6SSakari Ailus if (IS_ERR(val)) 3651df09bc6SSakari Ailus return PTR_ERR(val); 3661df09bc6SSakari Ailus 3671df09bc6SSakari Ailus *out_value = of_read_number(val, 2); 3681df09bc6SSakari Ailus return 0; 3691df09bc6SSakari Ailus } 3701df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_u64); 3711df09bc6SSakari Ailus 3721df09bc6SSakari Ailus /** 3731df09bc6SSakari Ailus * of_property_read_variable_u64_array - Find and read an array of 64 bit 3741df09bc6SSakari Ailus * integers from a property, with bounds on the minimum and maximum array size. 3751df09bc6SSakari Ailus * 3761df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 3771df09bc6SSakari Ailus * @propname: name of the property to be searched. 3787f3fefeeSMatti Vaittinen * @out_values: pointer to found values. 3791df09bc6SSakari Ailus * @sz_min: minimum number of array elements to read 3801df09bc6SSakari Ailus * @sz_max: maximum number of array elements to read, if zero there is no 3811df09bc6SSakari Ailus * upper limit on the number of elements in the dts entry but only 3821df09bc6SSakari Ailus * sz_min will be read. 3831df09bc6SSakari Ailus * 3841df09bc6SSakari Ailus * Search for a property in a device node and read 64-bit value(s) from 3858c8239c2SRob Herring * it. 3868c8239c2SRob Herring * 3878c8239c2SRob Herring * Return: The number of elements read on success, -EINVAL if the property 3881df09bc6SSakari Ailus * does not exist, -ENODATA if property does not have a value, and -EOVERFLOW 3891df09bc6SSakari Ailus * if the property data is smaller than sz_min or longer than sz_max. 3901df09bc6SSakari Ailus * 3911df09bc6SSakari Ailus * The out_values is modified only if a valid u64 value can be decoded. 3921df09bc6SSakari Ailus */ 3931df09bc6SSakari Ailus int of_property_read_variable_u64_array(const struct device_node *np, 3941df09bc6SSakari Ailus const char *propname, u64 *out_values, 3951df09bc6SSakari Ailus size_t sz_min, size_t sz_max) 3961df09bc6SSakari Ailus { 3971df09bc6SSakari Ailus size_t sz, count; 3981df09bc6SSakari Ailus const __be32 *val = of_find_property_value_of_size(np, propname, 3991df09bc6SSakari Ailus (sz_min * sizeof(*out_values)), 4001df09bc6SSakari Ailus (sz_max * sizeof(*out_values)), 4011df09bc6SSakari Ailus &sz); 4021df09bc6SSakari Ailus 4031df09bc6SSakari Ailus if (IS_ERR(val)) 4041df09bc6SSakari Ailus return PTR_ERR(val); 4051df09bc6SSakari Ailus 4061df09bc6SSakari Ailus if (!sz_max) 4071df09bc6SSakari Ailus sz = sz_min; 4081df09bc6SSakari Ailus else 4091df09bc6SSakari Ailus sz /= sizeof(*out_values); 4101df09bc6SSakari Ailus 4111df09bc6SSakari Ailus count = sz; 4121df09bc6SSakari Ailus while (count--) { 4131df09bc6SSakari Ailus *out_values++ = of_read_number(val, 2); 4141df09bc6SSakari Ailus val += 2; 4151df09bc6SSakari Ailus } 4161df09bc6SSakari Ailus 4171df09bc6SSakari Ailus return sz; 4181df09bc6SSakari Ailus } 4191df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_variable_u64_array); 4201df09bc6SSakari Ailus 4211df09bc6SSakari Ailus /** 4221df09bc6SSakari Ailus * of_property_read_string - Find and read a string from a property 4231df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 4241df09bc6SSakari Ailus * @propname: name of the property to be searched. 4251df09bc6SSakari Ailus * @out_string: pointer to null terminated return string, modified only if 4261df09bc6SSakari Ailus * return value is 0. 4271df09bc6SSakari Ailus * 4281df09bc6SSakari Ailus * Search for a property in a device tree node and retrieve a null 4298c8239c2SRob Herring * terminated string value (pointer to data, not a copy). 4308c8239c2SRob Herring * 4318c8239c2SRob Herring * Return: 0 on success, -EINVAL if the property does not exist, -ENODATA if 4328c8239c2SRob Herring * property does not have a value, and -EILSEQ if the string is not 4338c8239c2SRob Herring * null-terminated within the length of the property data. 4341df09bc6SSakari Ailus * 4351df09bc6SSakari Ailus * The out_string pointer is modified only if a valid string can be decoded. 4361df09bc6SSakari Ailus */ 4371df09bc6SSakari Ailus int of_property_read_string(const struct device_node *np, const char *propname, 4381df09bc6SSakari Ailus const char **out_string) 4391df09bc6SSakari Ailus { 4401df09bc6SSakari Ailus const struct property *prop = of_find_property(np, propname, NULL); 4411df09bc6SSakari Ailus if (!prop) 4421df09bc6SSakari Ailus return -EINVAL; 4431df09bc6SSakari Ailus if (!prop->value) 4441df09bc6SSakari Ailus return -ENODATA; 4451df09bc6SSakari Ailus if (strnlen(prop->value, prop->length) >= prop->length) 4461df09bc6SSakari Ailus return -EILSEQ; 4471df09bc6SSakari Ailus *out_string = prop->value; 4481df09bc6SSakari Ailus return 0; 4491df09bc6SSakari Ailus } 4501df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_string); 4511df09bc6SSakari Ailus 4521df09bc6SSakari Ailus /** 4531df09bc6SSakari Ailus * of_property_match_string() - Find string in a list and return index 4541df09bc6SSakari Ailus * @np: pointer to node containing string list property 4551df09bc6SSakari Ailus * @propname: string list property name 4561df09bc6SSakari Ailus * @string: pointer to string to search for in string list 4571df09bc6SSakari Ailus * 4581df09bc6SSakari Ailus * This function searches a string list property and returns the index 4591df09bc6SSakari Ailus * of a specific string value. 4601df09bc6SSakari Ailus */ 4611df09bc6SSakari Ailus int of_property_match_string(const struct device_node *np, const char *propname, 4621df09bc6SSakari Ailus const char *string) 4631df09bc6SSakari Ailus { 4641df09bc6SSakari Ailus const struct property *prop = of_find_property(np, propname, NULL); 4651df09bc6SSakari Ailus size_t l; 4661df09bc6SSakari Ailus int i; 4671df09bc6SSakari Ailus const char *p, *end; 4681df09bc6SSakari Ailus 4691df09bc6SSakari Ailus if (!prop) 4701df09bc6SSakari Ailus return -EINVAL; 4711df09bc6SSakari Ailus if (!prop->value) 4721df09bc6SSakari Ailus return -ENODATA; 4731df09bc6SSakari Ailus 4741df09bc6SSakari Ailus p = prop->value; 4751df09bc6SSakari Ailus end = p + prop->length; 4761df09bc6SSakari Ailus 4771df09bc6SSakari Ailus for (i = 0; p < end; i++, p += l) { 4781df09bc6SSakari Ailus l = strnlen(p, end - p) + 1; 4791df09bc6SSakari Ailus if (p + l > end) 4801df09bc6SSakari Ailus return -EILSEQ; 4811df09bc6SSakari Ailus pr_debug("comparing %s with %s\n", string, p); 4821df09bc6SSakari Ailus if (strcmp(string, p) == 0) 4831df09bc6SSakari Ailus return i; /* Found it; return index */ 4841df09bc6SSakari Ailus } 4851df09bc6SSakari Ailus return -ENODATA; 4861df09bc6SSakari Ailus } 4871df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_match_string); 4881df09bc6SSakari Ailus 4891df09bc6SSakari Ailus /** 4901df09bc6SSakari Ailus * of_property_read_string_helper() - Utility helper for parsing string properties 4911df09bc6SSakari Ailus * @np: device node from which the property value is to be read. 4921df09bc6SSakari Ailus * @propname: name of the property to be searched. 4931df09bc6SSakari Ailus * @out_strs: output array of string pointers. 4941df09bc6SSakari Ailus * @sz: number of array elements to read. 4951df09bc6SSakari Ailus * @skip: Number of strings to skip over at beginning of list. 4961df09bc6SSakari Ailus * 4971df09bc6SSakari Ailus * Don't call this function directly. It is a utility helper for the 4981df09bc6SSakari Ailus * of_property_read_string*() family of functions. 4991df09bc6SSakari Ailus */ 5001df09bc6SSakari Ailus int of_property_read_string_helper(const struct device_node *np, 5011df09bc6SSakari Ailus const char *propname, const char **out_strs, 5021df09bc6SSakari Ailus size_t sz, int skip) 5031df09bc6SSakari Ailus { 5041df09bc6SSakari Ailus const struct property *prop = of_find_property(np, propname, NULL); 5051df09bc6SSakari Ailus int l = 0, i = 0; 5061df09bc6SSakari Ailus const char *p, *end; 5071df09bc6SSakari Ailus 5081df09bc6SSakari Ailus if (!prop) 5091df09bc6SSakari Ailus return -EINVAL; 5101df09bc6SSakari Ailus if (!prop->value) 5111df09bc6SSakari Ailus return -ENODATA; 5121df09bc6SSakari Ailus p = prop->value; 5131df09bc6SSakari Ailus end = p + prop->length; 5141df09bc6SSakari Ailus 5151df09bc6SSakari Ailus for (i = 0; p < end && (!out_strs || i < skip + sz); i++, p += l) { 5161df09bc6SSakari Ailus l = strnlen(p, end - p) + 1; 5171df09bc6SSakari Ailus if (p + l > end) 5181df09bc6SSakari Ailus return -EILSEQ; 5191df09bc6SSakari Ailus if (out_strs && i >= skip) 5201df09bc6SSakari Ailus *out_strs++ = p; 5211df09bc6SSakari Ailus } 5221df09bc6SSakari Ailus i -= skip; 5231df09bc6SSakari Ailus return i <= 0 ? -ENODATA : i; 5241df09bc6SSakari Ailus } 5251df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_property_read_string_helper); 5261df09bc6SSakari Ailus 5271df09bc6SSakari Ailus const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur, 5281df09bc6SSakari Ailus u32 *pu) 5291df09bc6SSakari Ailus { 5301df09bc6SSakari Ailus const void *curv = cur; 5311df09bc6SSakari Ailus 5321df09bc6SSakari Ailus if (!prop) 5331df09bc6SSakari Ailus return NULL; 5341df09bc6SSakari Ailus 5351df09bc6SSakari Ailus if (!cur) { 5361df09bc6SSakari Ailus curv = prop->value; 5371df09bc6SSakari Ailus goto out_val; 5381df09bc6SSakari Ailus } 5391df09bc6SSakari Ailus 5401df09bc6SSakari Ailus curv += sizeof(*cur); 5411df09bc6SSakari Ailus if (curv >= prop->value + prop->length) 5421df09bc6SSakari Ailus return NULL; 5431df09bc6SSakari Ailus 5441df09bc6SSakari Ailus out_val: 5451df09bc6SSakari Ailus *pu = be32_to_cpup(curv); 5461df09bc6SSakari Ailus return curv; 5471df09bc6SSakari Ailus } 5481df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_prop_next_u32); 5491df09bc6SSakari Ailus 5501df09bc6SSakari Ailus const char *of_prop_next_string(struct property *prop, const char *cur) 5511df09bc6SSakari Ailus { 5521df09bc6SSakari Ailus const void *curv = cur; 5531df09bc6SSakari Ailus 5541df09bc6SSakari Ailus if (!prop) 5551df09bc6SSakari Ailus return NULL; 5561df09bc6SSakari Ailus 5571df09bc6SSakari Ailus if (!cur) 5581df09bc6SSakari Ailus return prop->value; 5591df09bc6SSakari Ailus 5601df09bc6SSakari Ailus curv += strlen(cur) + 1; 5611df09bc6SSakari Ailus if (curv >= prop->value + prop->length) 5621df09bc6SSakari Ailus return NULL; 5631df09bc6SSakari Ailus 5641df09bc6SSakari Ailus return curv; 5651df09bc6SSakari Ailus } 5661df09bc6SSakari Ailus EXPORT_SYMBOL_GPL(of_prop_next_string); 5671df09bc6SSakari Ailus 5681df09bc6SSakari Ailus /** 5691df09bc6SSakari Ailus * of_graph_parse_endpoint() - parse common endpoint node properties 5701df09bc6SSakari Ailus * @node: pointer to endpoint device_node 5711df09bc6SSakari Ailus * @endpoint: pointer to the OF endpoint data structure 5721df09bc6SSakari Ailus * 5731df09bc6SSakari Ailus * The caller should hold a reference to @node. 5741df09bc6SSakari Ailus */ 5751df09bc6SSakari Ailus int of_graph_parse_endpoint(const struct device_node *node, 5761df09bc6SSakari Ailus struct of_endpoint *endpoint) 5771df09bc6SSakari Ailus { 5781df09bc6SSakari Ailus struct device_node *port_node = of_get_parent(node); 5791df09bc6SSakari Ailus 5800d638a07SRob Herring WARN_ONCE(!port_node, "%s(): endpoint %pOF has no parent node\n", 5810d638a07SRob Herring __func__, node); 5821df09bc6SSakari Ailus 5831df09bc6SSakari Ailus memset(endpoint, 0, sizeof(*endpoint)); 5841df09bc6SSakari Ailus 5851df09bc6SSakari Ailus endpoint->local_node = node; 5861df09bc6SSakari Ailus /* 5871df09bc6SSakari Ailus * It doesn't matter whether the two calls below succeed. 5881df09bc6SSakari Ailus * If they don't then the default value 0 is used. 5891df09bc6SSakari Ailus */ 5901df09bc6SSakari Ailus of_property_read_u32(port_node, "reg", &endpoint->port); 5911df09bc6SSakari Ailus of_property_read_u32(node, "reg", &endpoint->id); 5921df09bc6SSakari Ailus 5931df09bc6SSakari Ailus of_node_put(port_node); 5941df09bc6SSakari Ailus 5951df09bc6SSakari Ailus return 0; 5961df09bc6SSakari Ailus } 5971df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_parse_endpoint); 5981df09bc6SSakari Ailus 5991df09bc6SSakari Ailus /** 6001df09bc6SSakari Ailus * of_graph_get_port_by_id() - get the port matching a given id 6011df09bc6SSakari Ailus * @parent: pointer to the parent device node 6021df09bc6SSakari Ailus * @id: id of the port 6031df09bc6SSakari Ailus * 6041df09bc6SSakari Ailus * Return: A 'port' node pointer with refcount incremented. The caller 6051df09bc6SSakari Ailus * has to use of_node_put() on it when done. 6061df09bc6SSakari Ailus */ 6071df09bc6SSakari Ailus struct device_node *of_graph_get_port_by_id(struct device_node *parent, u32 id) 6081df09bc6SSakari Ailus { 6091df09bc6SSakari Ailus struct device_node *node, *port; 6101df09bc6SSakari Ailus 6111df09bc6SSakari Ailus node = of_get_child_by_name(parent, "ports"); 6121df09bc6SSakari Ailus if (node) 6131df09bc6SSakari Ailus parent = node; 6141df09bc6SSakari Ailus 6151df09bc6SSakari Ailus for_each_child_of_node(parent, port) { 6161df09bc6SSakari Ailus u32 port_id = 0; 6171df09bc6SSakari Ailus 618b3e46d1aSRob Herring if (!of_node_name_eq(port, "port")) 6191df09bc6SSakari Ailus continue; 6201df09bc6SSakari Ailus of_property_read_u32(port, "reg", &port_id); 6211df09bc6SSakari Ailus if (id == port_id) 6221df09bc6SSakari Ailus break; 6231df09bc6SSakari Ailus } 6241df09bc6SSakari Ailus 6251df09bc6SSakari Ailus of_node_put(node); 6261df09bc6SSakari Ailus 6271df09bc6SSakari Ailus return port; 6281df09bc6SSakari Ailus } 6291df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_port_by_id); 6301df09bc6SSakari Ailus 6311df09bc6SSakari Ailus /** 6321df09bc6SSakari Ailus * of_graph_get_next_endpoint() - get next endpoint node 6331df09bc6SSakari Ailus * @parent: pointer to the parent device node 6341df09bc6SSakari Ailus * @prev: previous endpoint node, or NULL to get first 6351df09bc6SSakari Ailus * 6361df09bc6SSakari Ailus * Return: An 'endpoint' node pointer with refcount incremented. Refcount 6371df09bc6SSakari Ailus * of the passed @prev node is decremented. 6381df09bc6SSakari Ailus */ 6391df09bc6SSakari Ailus struct device_node *of_graph_get_next_endpoint(const struct device_node *parent, 6401df09bc6SSakari Ailus struct device_node *prev) 6411df09bc6SSakari Ailus { 6421df09bc6SSakari Ailus struct device_node *endpoint; 6431df09bc6SSakari Ailus struct device_node *port; 6441df09bc6SSakari Ailus 6451df09bc6SSakari Ailus if (!parent) 6461df09bc6SSakari Ailus return NULL; 6471df09bc6SSakari Ailus 6481df09bc6SSakari Ailus /* 6491df09bc6SSakari Ailus * Start by locating the port node. If no previous endpoint is specified 6501df09bc6SSakari Ailus * search for the first port node, otherwise get the previous endpoint 6511df09bc6SSakari Ailus * parent port node. 6521df09bc6SSakari Ailus */ 6531df09bc6SSakari Ailus if (!prev) { 6541df09bc6SSakari Ailus struct device_node *node; 6551df09bc6SSakari Ailus 6561df09bc6SSakari Ailus node = of_get_child_by_name(parent, "ports"); 6571df09bc6SSakari Ailus if (node) 6581df09bc6SSakari Ailus parent = node; 6591df09bc6SSakari Ailus 6601df09bc6SSakari Ailus port = of_get_child_by_name(parent, "port"); 6611df09bc6SSakari Ailus of_node_put(node); 6621df09bc6SSakari Ailus 6631df09bc6SSakari Ailus if (!port) { 6640d638a07SRob Herring pr_err("graph: no port node found in %pOF\n", parent); 6651df09bc6SSakari Ailus return NULL; 6661df09bc6SSakari Ailus } 6671df09bc6SSakari Ailus } else { 6681df09bc6SSakari Ailus port = of_get_parent(prev); 6690d638a07SRob Herring if (WARN_ONCE(!port, "%s(): endpoint %pOF has no parent node\n", 6700d638a07SRob Herring __func__, prev)) 6711df09bc6SSakari Ailus return NULL; 6721df09bc6SSakari Ailus } 6731df09bc6SSakari Ailus 6741df09bc6SSakari Ailus while (1) { 6751df09bc6SSakari Ailus /* 6761df09bc6SSakari Ailus * Now that we have a port node, get the next endpoint by 6771df09bc6SSakari Ailus * getting the next child. If the previous endpoint is NULL this 6781df09bc6SSakari Ailus * will return the first child. 6791df09bc6SSakari Ailus */ 6801df09bc6SSakari Ailus endpoint = of_get_next_child(port, prev); 6811df09bc6SSakari Ailus if (endpoint) { 6821df09bc6SSakari Ailus of_node_put(port); 6831df09bc6SSakari Ailus return endpoint; 6841df09bc6SSakari Ailus } 6851df09bc6SSakari Ailus 6861df09bc6SSakari Ailus /* No more endpoints under this port, try the next one. */ 6871df09bc6SSakari Ailus prev = NULL; 6881df09bc6SSakari Ailus 6891df09bc6SSakari Ailus do { 6901df09bc6SSakari Ailus port = of_get_next_child(parent, port); 6911df09bc6SSakari Ailus if (!port) 6921df09bc6SSakari Ailus return NULL; 693b3e46d1aSRob Herring } while (!of_node_name_eq(port, "port")); 6941df09bc6SSakari Ailus } 6951df09bc6SSakari Ailus } 6961df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_next_endpoint); 6971df09bc6SSakari Ailus 6981df09bc6SSakari Ailus /** 6991df09bc6SSakari Ailus * of_graph_get_endpoint_by_regs() - get endpoint node of specific identifiers 7001df09bc6SSakari Ailus * @parent: pointer to the parent device node 7011df09bc6SSakari Ailus * @port_reg: identifier (value of reg property) of the parent port node 7021df09bc6SSakari Ailus * @reg: identifier (value of reg property) of the endpoint node 7031df09bc6SSakari Ailus * 7041df09bc6SSakari Ailus * Return: An 'endpoint' node pointer which is identified by reg and at the same 7051df09bc6SSakari Ailus * is the child of a port node identified by port_reg. reg and port_reg are 706deb387d4SMaxime Ripard * ignored when they are -1. Use of_node_put() on the pointer when done. 7071df09bc6SSakari Ailus */ 7081df09bc6SSakari Ailus struct device_node *of_graph_get_endpoint_by_regs( 7091df09bc6SSakari Ailus const struct device_node *parent, int port_reg, int reg) 7101df09bc6SSakari Ailus { 7111df09bc6SSakari Ailus struct of_endpoint endpoint; 7121df09bc6SSakari Ailus struct device_node *node = NULL; 7131df09bc6SSakari Ailus 7141df09bc6SSakari Ailus for_each_endpoint_of_node(parent, node) { 7151df09bc6SSakari Ailus of_graph_parse_endpoint(node, &endpoint); 7161df09bc6SSakari Ailus if (((port_reg == -1) || (endpoint.port == port_reg)) && 7171df09bc6SSakari Ailus ((reg == -1) || (endpoint.id == reg))) 7181df09bc6SSakari Ailus return node; 7191df09bc6SSakari Ailus } 7201df09bc6SSakari Ailus 7211df09bc6SSakari Ailus return NULL; 7221df09bc6SSakari Ailus } 7231df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_endpoint_by_regs); 7241df09bc6SSakari Ailus 7251df09bc6SSakari Ailus /** 726b8ba92b1SRob Herring * of_graph_get_remote_endpoint() - get remote endpoint node 727b8ba92b1SRob Herring * @node: pointer to a local endpoint device_node 728b8ba92b1SRob Herring * 729b8ba92b1SRob Herring * Return: Remote endpoint node associated with remote endpoint node linked 730b8ba92b1SRob Herring * to @node. Use of_node_put() on it when done. 731b8ba92b1SRob Herring */ 732b8ba92b1SRob Herring struct device_node *of_graph_get_remote_endpoint(const struct device_node *node) 733b8ba92b1SRob Herring { 734b8ba92b1SRob Herring /* Get remote endpoint node. */ 735b8ba92b1SRob Herring return of_parse_phandle(node, "remote-endpoint", 0); 736b8ba92b1SRob Herring } 737b8ba92b1SRob Herring EXPORT_SYMBOL(of_graph_get_remote_endpoint); 738b8ba92b1SRob Herring 739b8ba92b1SRob Herring /** 740b8ba92b1SRob Herring * of_graph_get_port_parent() - get port's parent node 741b8ba92b1SRob Herring * @node: pointer to a local endpoint device_node 742b8ba92b1SRob Herring * 743b8ba92b1SRob Herring * Return: device node associated with endpoint node linked 744b8ba92b1SRob Herring * to @node. Use of_node_put() on it when done. 745b8ba92b1SRob Herring */ 746b8ba92b1SRob Herring struct device_node *of_graph_get_port_parent(struct device_node *node) 747b8ba92b1SRob Herring { 748b8ba92b1SRob Herring unsigned int depth; 749b8ba92b1SRob Herring 750c0a480d1STony Lindgren if (!node) 751c0a480d1STony Lindgren return NULL; 752c0a480d1STony Lindgren 753c0a480d1STony Lindgren /* 754c0a480d1STony Lindgren * Preserve usecount for passed in node as of_get_next_parent() 755c0a480d1STony Lindgren * will do of_node_put() on it. 756c0a480d1STony Lindgren */ 757c0a480d1STony Lindgren of_node_get(node); 758c0a480d1STony Lindgren 759b8ba92b1SRob Herring /* Walk 3 levels up only if there is 'ports' node. */ 760b8ba92b1SRob Herring for (depth = 3; depth && node; depth--) { 761b8ba92b1SRob Herring node = of_get_next_parent(node); 762b3e46d1aSRob Herring if (depth == 2 && !of_node_name_eq(node, "ports")) 763b8ba92b1SRob Herring break; 764b8ba92b1SRob Herring } 765b8ba92b1SRob Herring return node; 766b8ba92b1SRob Herring } 767b8ba92b1SRob Herring EXPORT_SYMBOL(of_graph_get_port_parent); 768b8ba92b1SRob Herring 769b8ba92b1SRob Herring /** 7701df09bc6SSakari Ailus * of_graph_get_remote_port_parent() - get remote port's parent node 7711df09bc6SSakari Ailus * @node: pointer to a local endpoint device_node 7721df09bc6SSakari Ailus * 7731df09bc6SSakari Ailus * Return: Remote device node associated with remote endpoint node linked 7741df09bc6SSakari Ailus * to @node. Use of_node_put() on it when done. 7751df09bc6SSakari Ailus */ 7761df09bc6SSakari Ailus struct device_node *of_graph_get_remote_port_parent( 7771df09bc6SSakari Ailus const struct device_node *node) 7781df09bc6SSakari Ailus { 779c0a480d1STony Lindgren struct device_node *np, *pp; 7801df09bc6SSakari Ailus 7811df09bc6SSakari Ailus /* Get remote endpoint node. */ 782b8ba92b1SRob Herring np = of_graph_get_remote_endpoint(node); 7831df09bc6SSakari Ailus 784c0a480d1STony Lindgren pp = of_graph_get_port_parent(np); 785c0a480d1STony Lindgren 786c0a480d1STony Lindgren of_node_put(np); 787c0a480d1STony Lindgren 788c0a480d1STony Lindgren return pp; 7891df09bc6SSakari Ailus } 7901df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_remote_port_parent); 7911df09bc6SSakari Ailus 7921df09bc6SSakari Ailus /** 7931df09bc6SSakari Ailus * of_graph_get_remote_port() - get remote port node 7941df09bc6SSakari Ailus * @node: pointer to a local endpoint device_node 7951df09bc6SSakari Ailus * 7961df09bc6SSakari Ailus * Return: Remote port node associated with remote endpoint node linked 7971df09bc6SSakari Ailus * to @node. Use of_node_put() on it when done. 7981df09bc6SSakari Ailus */ 7991df09bc6SSakari Ailus struct device_node *of_graph_get_remote_port(const struct device_node *node) 8001df09bc6SSakari Ailus { 8011df09bc6SSakari Ailus struct device_node *np; 8021df09bc6SSakari Ailus 8031df09bc6SSakari Ailus /* Get remote endpoint node. */ 804b8ba92b1SRob Herring np = of_graph_get_remote_endpoint(node); 8051df09bc6SSakari Ailus if (!np) 8061df09bc6SSakari Ailus return NULL; 8071df09bc6SSakari Ailus return of_get_next_parent(np); 8081df09bc6SSakari Ailus } 8091df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_remote_port); 8101df09bc6SSakari Ailus 811b8ba92b1SRob Herring int of_graph_get_endpoint_count(const struct device_node *np) 812b8ba92b1SRob Herring { 813b8ba92b1SRob Herring struct device_node *endpoint; 814b8ba92b1SRob Herring int num = 0; 815b8ba92b1SRob Herring 816b8ba92b1SRob Herring for_each_endpoint_of_node(np, endpoint) 817b8ba92b1SRob Herring num++; 818b8ba92b1SRob Herring 819b8ba92b1SRob Herring return num; 820b8ba92b1SRob Herring } 821b8ba92b1SRob Herring EXPORT_SYMBOL(of_graph_get_endpoint_count); 822b8ba92b1SRob Herring 8231df09bc6SSakari Ailus /** 8241df09bc6SSakari Ailus * of_graph_get_remote_node() - get remote parent device_node for given port/endpoint 8251df09bc6SSakari Ailus * @node: pointer to parent device_node containing graph port/endpoint 8261df09bc6SSakari Ailus * @port: identifier (value of reg property) of the parent port node 8271df09bc6SSakari Ailus * @endpoint: identifier (value of reg property) of the endpoint node 8281df09bc6SSakari Ailus * 8291df09bc6SSakari Ailus * Return: Remote device node associated with remote endpoint node linked 8301df09bc6SSakari Ailus * to @node. Use of_node_put() on it when done. 8311df09bc6SSakari Ailus */ 8321df09bc6SSakari Ailus struct device_node *of_graph_get_remote_node(const struct device_node *node, 8331df09bc6SSakari Ailus u32 port, u32 endpoint) 8341df09bc6SSakari Ailus { 8351df09bc6SSakari Ailus struct device_node *endpoint_node, *remote; 8361df09bc6SSakari Ailus 8371df09bc6SSakari Ailus endpoint_node = of_graph_get_endpoint_by_regs(node, port, endpoint); 8381df09bc6SSakari Ailus if (!endpoint_node) { 8390d638a07SRob Herring pr_debug("no valid endpoint (%d, %d) for node %pOF\n", 8400d638a07SRob Herring port, endpoint, node); 8411df09bc6SSakari Ailus return NULL; 8421df09bc6SSakari Ailus } 8431df09bc6SSakari Ailus 8441df09bc6SSakari Ailus remote = of_graph_get_remote_port_parent(endpoint_node); 8451df09bc6SSakari Ailus of_node_put(endpoint_node); 8461df09bc6SSakari Ailus if (!remote) { 8471df09bc6SSakari Ailus pr_debug("no valid remote node\n"); 8481df09bc6SSakari Ailus return NULL; 8491df09bc6SSakari Ailus } 8501df09bc6SSakari Ailus 8511df09bc6SSakari Ailus if (!of_device_is_available(remote)) { 8521df09bc6SSakari Ailus pr_debug("not available for remote node\n"); 85328b170e8SJulia Lawall of_node_put(remote); 8541df09bc6SSakari Ailus return NULL; 8551df09bc6SSakari Ailus } 8561df09bc6SSakari Ailus 8571df09bc6SSakari Ailus return remote; 8581df09bc6SSakari Ailus } 8591df09bc6SSakari Ailus EXPORT_SYMBOL(of_graph_get_remote_node); 8603708184aSSakari Ailus 861cf89a31cSSakari Ailus static struct fwnode_handle *of_fwnode_get(struct fwnode_handle *fwnode) 8623708184aSSakari Ailus { 863cf89a31cSSakari Ailus return of_fwnode_handle(of_node_get(to_of_node(fwnode))); 8643708184aSSakari Ailus } 8653708184aSSakari Ailus 8663708184aSSakari Ailus static void of_fwnode_put(struct fwnode_handle *fwnode) 8673708184aSSakari Ailus { 8683708184aSSakari Ailus of_node_put(to_of_node(fwnode)); 8693708184aSSakari Ailus } 8703708184aSSakari Ailus 87137ba983cSSakari Ailus static bool of_fwnode_device_is_available(const struct fwnode_handle *fwnode) 8722294b3afSSakari Ailus { 8732294b3afSSakari Ailus return of_device_is_available(to_of_node(fwnode)); 8742294b3afSSakari Ailus } 8752294b3afSSakari Ailus 8768c756a0aSSakari Ailus static bool of_fwnode_device_dma_supported(const struct fwnode_handle *fwnode) 8778c756a0aSSakari Ailus { 8788c756a0aSSakari Ailus return true; 8798c756a0aSSakari Ailus } 8808c756a0aSSakari Ailus 8818c756a0aSSakari Ailus static enum dev_dma_attr 8828c756a0aSSakari Ailus of_fwnode_device_get_dma_attr(const struct fwnode_handle *fwnode) 8838c756a0aSSakari Ailus { 8848c756a0aSSakari Ailus if (of_dma_is_coherent(to_of_node(fwnode))) 8858c756a0aSSakari Ailus return DEV_DMA_COHERENT; 8868c756a0aSSakari Ailus else 8878c756a0aSSakari Ailus return DEV_DMA_NON_COHERENT; 8888c756a0aSSakari Ailus } 8898c756a0aSSakari Ailus 89037ba983cSSakari Ailus static bool of_fwnode_property_present(const struct fwnode_handle *fwnode, 8913708184aSSakari Ailus const char *propname) 8923708184aSSakari Ailus { 8933708184aSSakari Ailus return of_property_read_bool(to_of_node(fwnode), propname); 8943708184aSSakari Ailus } 8953708184aSSakari Ailus 89637ba983cSSakari Ailus static int of_fwnode_property_read_int_array(const struct fwnode_handle *fwnode, 8973708184aSSakari Ailus const char *propname, 8983708184aSSakari Ailus unsigned int elem_size, void *val, 8993708184aSSakari Ailus size_t nval) 9003708184aSSakari Ailus { 90137ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 9023708184aSSakari Ailus 9033708184aSSakari Ailus if (!val) 9043708184aSSakari Ailus return of_property_count_elems_of_size(node, propname, 9053708184aSSakari Ailus elem_size); 9063708184aSSakari Ailus 9073708184aSSakari Ailus switch (elem_size) { 9083708184aSSakari Ailus case sizeof(u8): 9093708184aSSakari Ailus return of_property_read_u8_array(node, propname, val, nval); 9103708184aSSakari Ailus case sizeof(u16): 9113708184aSSakari Ailus return of_property_read_u16_array(node, propname, val, nval); 9123708184aSSakari Ailus case sizeof(u32): 9133708184aSSakari Ailus return of_property_read_u32_array(node, propname, val, nval); 9143708184aSSakari Ailus case sizeof(u64): 9153708184aSSakari Ailus return of_property_read_u64_array(node, propname, val, nval); 9163708184aSSakari Ailus } 9173708184aSSakari Ailus 9183708184aSSakari Ailus return -ENXIO; 9193708184aSSakari Ailus } 9203708184aSSakari Ailus 92137ba983cSSakari Ailus static int 92237ba983cSSakari Ailus of_fwnode_property_read_string_array(const struct fwnode_handle *fwnode, 92337ba983cSSakari Ailus const char *propname, const char **val, 92437ba983cSSakari Ailus size_t nval) 9253708184aSSakari Ailus { 92637ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 9273708184aSSakari Ailus 9283708184aSSakari Ailus return val ? 9293708184aSSakari Ailus of_property_read_string_array(node, propname, val, nval) : 9303708184aSSakari Ailus of_property_count_strings(node, propname); 9313708184aSSakari Ailus } 9323708184aSSakari Ailus 933bc0500c1SSakari Ailus static const char *of_fwnode_get_name(const struct fwnode_handle *fwnode) 934bc0500c1SSakari Ailus { 935bc0500c1SSakari Ailus return kbasename(to_of_node(fwnode)->full_name); 936bc0500c1SSakari Ailus } 937bc0500c1SSakari Ailus 938e7e242bcSSakari Ailus static const char *of_fwnode_get_name_prefix(const struct fwnode_handle *fwnode) 939e7e242bcSSakari Ailus { 940e7e242bcSSakari Ailus /* Root needs no prefix here (its name is "/"). */ 941e7e242bcSSakari Ailus if (!to_of_node(fwnode)->parent) 942e7e242bcSSakari Ailus return ""; 943e7e242bcSSakari Ailus 944e7e242bcSSakari Ailus return "/"; 945e7e242bcSSakari Ailus } 946e7e242bcSSakari Ailus 94737ba983cSSakari Ailus static struct fwnode_handle * 94837ba983cSSakari Ailus of_fwnode_get_parent(const struct fwnode_handle *fwnode) 9493708184aSSakari Ailus { 9503708184aSSakari Ailus return of_fwnode_handle(of_get_parent(to_of_node(fwnode))); 9513708184aSSakari Ailus } 9523708184aSSakari Ailus 9533708184aSSakari Ailus static struct fwnode_handle * 95437ba983cSSakari Ailus of_fwnode_get_next_child_node(const struct fwnode_handle *fwnode, 9553708184aSSakari Ailus struct fwnode_handle *child) 9563708184aSSakari Ailus { 9573708184aSSakari Ailus return of_fwnode_handle(of_get_next_available_child(to_of_node(fwnode), 9583708184aSSakari Ailus to_of_node(child))); 9593708184aSSakari Ailus } 9603708184aSSakari Ailus 9613708184aSSakari Ailus static struct fwnode_handle * 96237ba983cSSakari Ailus of_fwnode_get_named_child_node(const struct fwnode_handle *fwnode, 9633708184aSSakari Ailus const char *childname) 9643708184aSSakari Ailus { 96537ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 9663708184aSSakari Ailus struct device_node *child; 9673708184aSSakari Ailus 9683708184aSSakari Ailus for_each_available_child_of_node(node, child) 969b3e46d1aSRob Herring if (of_node_name_eq(child, childname)) 9703708184aSSakari Ailus return of_fwnode_handle(child); 9713708184aSSakari Ailus 9723708184aSSakari Ailus return NULL; 9733708184aSSakari Ailus } 9743708184aSSakari Ailus 9753e3119d3SSakari Ailus static int 9763e3119d3SSakari Ailus of_fwnode_get_reference_args(const struct fwnode_handle *fwnode, 9773e3119d3SSakari Ailus const char *prop, const char *nargs_prop, 9783e3119d3SSakari Ailus unsigned int nargs, unsigned int index, 9793e3119d3SSakari Ailus struct fwnode_reference_args *args) 9803e3119d3SSakari Ailus { 9813e3119d3SSakari Ailus struct of_phandle_args of_args; 9823e3119d3SSakari Ailus unsigned int i; 9833e3119d3SSakari Ailus int ret; 9843e3119d3SSakari Ailus 9853e3119d3SSakari Ailus if (nargs_prop) 9863e3119d3SSakari Ailus ret = of_parse_phandle_with_args(to_of_node(fwnode), prop, 9873e3119d3SSakari Ailus nargs_prop, index, &of_args); 9883e3119d3SSakari Ailus else 9893e3119d3SSakari Ailus ret = of_parse_phandle_with_fixed_args(to_of_node(fwnode), prop, 9903e3119d3SSakari Ailus nargs, index, &of_args); 9913e3119d3SSakari Ailus if (ret < 0) 9923e3119d3SSakari Ailus return ret; 9933e3119d3SSakari Ailus if (!args) 9943e3119d3SSakari Ailus return 0; 9953e3119d3SSakari Ailus 9963e3119d3SSakari Ailus args->nargs = of_args.args_count; 9973e3119d3SSakari Ailus args->fwnode = of_fwnode_handle(of_args.np); 9983e3119d3SSakari Ailus 9993e3119d3SSakari Ailus for (i = 0; i < NR_FWNODE_REFERENCE_ARGS; i++) 10003e3119d3SSakari Ailus args->args[i] = i < of_args.args_count ? of_args.args[i] : 0; 10013e3119d3SSakari Ailus 10023e3119d3SSakari Ailus return 0; 10033e3119d3SSakari Ailus } 10043e3119d3SSakari Ailus 10053b27d00eSSakari Ailus static struct fwnode_handle * 100637ba983cSSakari Ailus of_fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode, 10073b27d00eSSakari Ailus struct fwnode_handle *prev) 10083b27d00eSSakari Ailus { 10093b27d00eSSakari Ailus return of_fwnode_handle(of_graph_get_next_endpoint(to_of_node(fwnode), 10103b27d00eSSakari Ailus to_of_node(prev))); 10113b27d00eSSakari Ailus } 10123b27d00eSSakari Ailus 10133b27d00eSSakari Ailus static struct fwnode_handle * 101437ba983cSSakari Ailus of_fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode) 10153b27d00eSSakari Ailus { 1016358155edSKuninori Morimoto return of_fwnode_handle( 1017358155edSKuninori Morimoto of_graph_get_remote_endpoint(to_of_node(fwnode))); 10183b27d00eSSakari Ailus } 10193b27d00eSSakari Ailus 10203b27d00eSSakari Ailus static struct fwnode_handle * 10213b27d00eSSakari Ailus of_fwnode_graph_get_port_parent(struct fwnode_handle *fwnode) 10223b27d00eSSakari Ailus { 10233b27d00eSSakari Ailus struct device_node *np; 10243b27d00eSSakari Ailus 10253b27d00eSSakari Ailus /* Get the parent of the port */ 10263314c6bdSNiklas Söderlund np = of_get_parent(to_of_node(fwnode)); 10273b27d00eSSakari Ailus if (!np) 10283b27d00eSSakari Ailus return NULL; 10293b27d00eSSakari Ailus 10303b27d00eSSakari Ailus /* Is this the "ports" node? If not, it's the port parent. */ 1031b3e46d1aSRob Herring if (!of_node_name_eq(np, "ports")) 10323b27d00eSSakari Ailus return of_fwnode_handle(np); 10333b27d00eSSakari Ailus 10343b27d00eSSakari Ailus return of_fwnode_handle(of_get_next_parent(np)); 10353b27d00eSSakari Ailus } 10363b27d00eSSakari Ailus 103737ba983cSSakari Ailus static int of_fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode, 10383b27d00eSSakari Ailus struct fwnode_endpoint *endpoint) 10393b27d00eSSakari Ailus { 104037ba983cSSakari Ailus const struct device_node *node = to_of_node(fwnode); 10413b27d00eSSakari Ailus struct device_node *port_node = of_get_parent(node); 10423b27d00eSSakari Ailus 10433b27d00eSSakari Ailus endpoint->local_fwnode = fwnode; 10443b27d00eSSakari Ailus 10453b27d00eSSakari Ailus of_property_read_u32(port_node, "reg", &endpoint->port); 10463b27d00eSSakari Ailus of_property_read_u32(node, "reg", &endpoint->id); 10473b27d00eSSakari Ailus 10483b27d00eSSakari Ailus of_node_put(port_node); 10493b27d00eSSakari Ailus 10503b27d00eSSakari Ailus return 0; 10513b27d00eSSakari Ailus } 10523b27d00eSSakari Ailus 105367dcc26dSAndy Shevchenko static const void * 10541c2c82eaSSinan Kaya of_fwnode_device_get_match_data(const struct fwnode_handle *fwnode, 10551c2c82eaSSinan Kaya const struct device *dev) 10561c2c82eaSSinan Kaya { 105767dcc26dSAndy Shevchenko return of_device_get_match_data(dev); 10581c2c82eaSSinan Kaya } 10591c2c82eaSSinan Kaya 1060a3e1d1a7SSaravana Kannan static bool of_is_ancestor_of(struct device_node *test_ancestor, 1061a3e1d1a7SSaravana Kannan struct device_node *child) 1062a3e1d1a7SSaravana Kannan { 1063a3e1d1a7SSaravana Kannan of_node_get(child); 1064a3e1d1a7SSaravana Kannan while (child) { 1065a3e1d1a7SSaravana Kannan if (child == test_ancestor) { 1066a3e1d1a7SSaravana Kannan of_node_put(child); 106738835391SSaravana Kannan return true; 1068a3e1d1a7SSaravana Kannan } 1069a3e1d1a7SSaravana Kannan child = of_get_next_parent(child); 1070a3e1d1a7SSaravana Kannan } 107138835391SSaravana Kannan return false; 1072a3e1d1a7SSaravana Kannan } 1073a3e1d1a7SSaravana Kannan 1074f7514a66SSaravana Kannan static struct device_node *of_get_compat_node(struct device_node *np) 1075f7514a66SSaravana Kannan { 1076f7514a66SSaravana Kannan of_node_get(np); 1077f7514a66SSaravana Kannan 1078f7514a66SSaravana Kannan while (np) { 1079f7514a66SSaravana Kannan if (!of_device_is_available(np)) { 1080f7514a66SSaravana Kannan of_node_put(np); 1081f7514a66SSaravana Kannan np = NULL; 1082f7514a66SSaravana Kannan } 1083f7514a66SSaravana Kannan 1084f7514a66SSaravana Kannan if (of_find_property(np, "compatible", NULL)) 1085f7514a66SSaravana Kannan break; 1086f7514a66SSaravana Kannan 1087f7514a66SSaravana Kannan np = of_get_next_parent(np); 1088f7514a66SSaravana Kannan } 1089f7514a66SSaravana Kannan 1090f7514a66SSaravana Kannan return np; 1091f7514a66SSaravana Kannan } 1092f7514a66SSaravana Kannan 10933cd6bab2SUlf Hansson static struct device_node *of_get_compat_node_parent(struct device_node *np) 10943cd6bab2SUlf Hansson { 10953cd6bab2SUlf Hansson struct device_node *parent, *node; 10963cd6bab2SUlf Hansson 10973cd6bab2SUlf Hansson parent = of_get_parent(np); 10983cd6bab2SUlf Hansson node = of_get_compat_node(parent); 10993cd6bab2SUlf Hansson of_node_put(parent); 11003cd6bab2SUlf Hansson 11013cd6bab2SUlf Hansson return node; 11023cd6bab2SUlf Hansson } 11033cd6bab2SUlf Hansson 1104a3e1d1a7SSaravana Kannan /** 11058a06d1eaSSaravana Kannan * of_link_to_phandle - Add fwnode link to supplier from supplier phandle 11068a06d1eaSSaravana Kannan * @con_np: consumer device tree node 11078a06d1eaSSaravana Kannan * @sup_np: supplier device tree node 1108a3e1d1a7SSaravana Kannan * 1109a3e1d1a7SSaravana Kannan * Given a phandle to a supplier device tree node (@sup_np), this function 1110a3e1d1a7SSaravana Kannan * finds the device that owns the supplier device tree node and creates a 1111a3e1d1a7SSaravana Kannan * device link from @dev consumer device to the supplier device. This function 1112a3e1d1a7SSaravana Kannan * doesn't create device links for invalid scenarios such as trying to create a 1113a3e1d1a7SSaravana Kannan * link with a parent device as the consumer of its child device. In such 1114a3e1d1a7SSaravana Kannan * cases, it returns an error. 1115a3e1d1a7SSaravana Kannan * 1116a3e1d1a7SSaravana Kannan * Returns: 11178a06d1eaSSaravana Kannan * - 0 if fwnode link successfully created to supplier 1118a3e1d1a7SSaravana Kannan * - -EINVAL if the supplier link is invalid and should not be created 11198a06d1eaSSaravana Kannan * - -ENODEV if struct device will never be create for supplier 1120a3e1d1a7SSaravana Kannan */ 11218a06d1eaSSaravana Kannan static int of_link_to_phandle(struct device_node *con_np, 11228a06d1eaSSaravana Kannan struct device_node *sup_np) 1123a3e1d1a7SSaravana Kannan { 11248a06d1eaSSaravana Kannan struct device *sup_dev; 1125a3e1d1a7SSaravana Kannan struct device_node *tmp_np = sup_np; 1126a3e1d1a7SSaravana Kannan 1127a3e1d1a7SSaravana Kannan /* 1128a3e1d1a7SSaravana Kannan * Find the device node that contains the supplier phandle. It may be 1129a3e1d1a7SSaravana Kannan * @sup_np or it may be an ancestor of @sup_np. 1130a3e1d1a7SSaravana Kannan */ 1131f7514a66SSaravana Kannan sup_np = of_get_compat_node(sup_np); 1132a3e1d1a7SSaravana Kannan if (!sup_np) { 11338a06d1eaSSaravana Kannan pr_debug("Not linking %pOFP to %pOFP - No device\n", 11348a06d1eaSSaravana Kannan con_np, tmp_np); 1135a3e1d1a7SSaravana Kannan return -ENODEV; 1136a3e1d1a7SSaravana Kannan } 1137a3e1d1a7SSaravana Kannan 1138a3e1d1a7SSaravana Kannan /* 1139a3e1d1a7SSaravana Kannan * Don't allow linking a device node as a consumer of one of its 1140a3e1d1a7SSaravana Kannan * descendant nodes. By definition, a child node can't be a functional 1141a3e1d1a7SSaravana Kannan * dependency for the parent node. 1142a3e1d1a7SSaravana Kannan */ 11438a06d1eaSSaravana Kannan if (of_is_ancestor_of(con_np, sup_np)) { 11448a06d1eaSSaravana Kannan pr_debug("Not linking %pOFP to %pOFP - is descendant\n", 11458a06d1eaSSaravana Kannan con_np, sup_np); 1146a3e1d1a7SSaravana Kannan of_node_put(sup_np); 1147a3e1d1a7SSaravana Kannan return -EINVAL; 1148a3e1d1a7SSaravana Kannan } 11498a06d1eaSSaravana Kannan 11508a06d1eaSSaravana Kannan /* 11518a06d1eaSSaravana Kannan * Don't create links to "early devices" that won't have struct devices 11528a06d1eaSSaravana Kannan * created for them. 11538a06d1eaSSaravana Kannan */ 1154a3e1d1a7SSaravana Kannan sup_dev = get_dev_from_fwnode(&sup_np->fwnode); 11551753c4d1SSaravana Kannan if (!sup_dev && 11561753c4d1SSaravana Kannan (of_node_check_flag(sup_np, OF_POPULATED) || 11571753c4d1SSaravana Kannan sup_np->fwnode.flags & FWNODE_FLAG_NOT_DEVICE)) { 11588a06d1eaSSaravana Kannan pr_debug("Not linking %pOFP to %pOFP - No struct device\n", 11598a06d1eaSSaravana Kannan con_np, sup_np); 1160bb278b14SSaravana Kannan of_node_put(sup_np); 1161ba861f8eSSaravana Kannan return -ENODEV; 1162ba861f8eSSaravana Kannan } 1163a3e1d1a7SSaravana Kannan put_device(sup_dev); 11648a06d1eaSSaravana Kannan 11658a06d1eaSSaravana Kannan fwnode_link_add(of_fwnode_handle(con_np), of_fwnode_handle(sup_np)); 11668a06d1eaSSaravana Kannan of_node_put(sup_np); 11678a06d1eaSSaravana Kannan 11688a06d1eaSSaravana Kannan return 0; 1169a3e1d1a7SSaravana Kannan } 1170a3e1d1a7SSaravana Kannan 1171a3e1d1a7SSaravana Kannan /** 1172a3e1d1a7SSaravana Kannan * parse_prop_cells - Property parsing function for suppliers 1173a3e1d1a7SSaravana Kannan * 1174a3e1d1a7SSaravana Kannan * @np: Pointer to device tree node containing a list 1175a3e1d1a7SSaravana Kannan * @prop_name: Name of property to be parsed. Expected to hold phandle values 1176a3e1d1a7SSaravana Kannan * @index: For properties holding a list of phandles, this is the index 1177a3e1d1a7SSaravana Kannan * into the list. 1178a3e1d1a7SSaravana Kannan * @list_name: Property name that is known to contain list of phandle(s) to 1179a3e1d1a7SSaravana Kannan * supplier(s) 1180a3e1d1a7SSaravana Kannan * @cells_name: property name that specifies phandles' arguments count 1181a3e1d1a7SSaravana Kannan * 1182a3e1d1a7SSaravana Kannan * This is a helper function to parse properties that have a known fixed name 1183a3e1d1a7SSaravana Kannan * and are a list of phandles and phandle arguments. 1184a3e1d1a7SSaravana Kannan * 1185a3e1d1a7SSaravana Kannan * Returns: 1186a3e1d1a7SSaravana Kannan * - phandle node pointer with refcount incremented. Caller must of_node_put() 1187a3e1d1a7SSaravana Kannan * on it when done. 1188a3e1d1a7SSaravana Kannan * - NULL if no phandle found at index 1189a3e1d1a7SSaravana Kannan */ 1190a3e1d1a7SSaravana Kannan static struct device_node *parse_prop_cells(struct device_node *np, 1191a3e1d1a7SSaravana Kannan const char *prop_name, int index, 1192a3e1d1a7SSaravana Kannan const char *list_name, 1193a3e1d1a7SSaravana Kannan const char *cells_name) 1194a3e1d1a7SSaravana Kannan { 1195a3e1d1a7SSaravana Kannan struct of_phandle_args sup_args; 1196a3e1d1a7SSaravana Kannan 1197a3e1d1a7SSaravana Kannan if (strcmp(prop_name, list_name)) 1198a3e1d1a7SSaravana Kannan return NULL; 1199a3e1d1a7SSaravana Kannan 1200a3e1d1a7SSaravana Kannan if (of_parse_phandle_with_args(np, list_name, cells_name, index, 1201a3e1d1a7SSaravana Kannan &sup_args)) 1202a3e1d1a7SSaravana Kannan return NULL; 1203a3e1d1a7SSaravana Kannan 1204a3e1d1a7SSaravana Kannan return sup_args.np; 1205a3e1d1a7SSaravana Kannan } 1206a3e1d1a7SSaravana Kannan 1207a436ef4aSSaravana Kannan #define DEFINE_SIMPLE_PROP(fname, name, cells) \ 1208a436ef4aSSaravana Kannan static struct device_node *parse_##fname(struct device_node *np, \ 1209a436ef4aSSaravana Kannan const char *prop_name, int index) \ 1210a436ef4aSSaravana Kannan { \ 1211a436ef4aSSaravana Kannan return parse_prop_cells(np, prop_name, index, name, cells); \ 1212a3e1d1a7SSaravana Kannan } 1213a3e1d1a7SSaravana Kannan 1214a3e1d1a7SSaravana Kannan static int strcmp_suffix(const char *str, const char *suffix) 1215a3e1d1a7SSaravana Kannan { 1216a3e1d1a7SSaravana Kannan unsigned int len, suffix_len; 1217a3e1d1a7SSaravana Kannan 1218a3e1d1a7SSaravana Kannan len = strlen(str); 1219a3e1d1a7SSaravana Kannan suffix_len = strlen(suffix); 1220a3e1d1a7SSaravana Kannan if (len <= suffix_len) 1221a3e1d1a7SSaravana Kannan return -1; 1222a3e1d1a7SSaravana Kannan return strcmp(str + len - suffix_len, suffix); 1223a3e1d1a7SSaravana Kannan } 1224a3e1d1a7SSaravana Kannan 1225a436ef4aSSaravana Kannan /** 1226a436ef4aSSaravana Kannan * parse_suffix_prop_cells - Suffix property parsing function for suppliers 1227a436ef4aSSaravana Kannan * 1228a436ef4aSSaravana Kannan * @np: Pointer to device tree node containing a list 1229a436ef4aSSaravana Kannan * @prop_name: Name of property to be parsed. Expected to hold phandle values 1230a436ef4aSSaravana Kannan * @index: For properties holding a list of phandles, this is the index 1231a436ef4aSSaravana Kannan * into the list. 1232a436ef4aSSaravana Kannan * @suffix: Property suffix that is known to contain list of phandle(s) to 1233a436ef4aSSaravana Kannan * supplier(s) 1234a436ef4aSSaravana Kannan * @cells_name: property name that specifies phandles' arguments count 1235a436ef4aSSaravana Kannan * 1236a436ef4aSSaravana Kannan * This is a helper function to parse properties that have a known fixed suffix 1237a436ef4aSSaravana Kannan * and are a list of phandles and phandle arguments. 1238a436ef4aSSaravana Kannan * 1239a436ef4aSSaravana Kannan * Returns: 1240a436ef4aSSaravana Kannan * - phandle node pointer with refcount incremented. Caller must of_node_put() 1241a436ef4aSSaravana Kannan * on it when done. 1242a436ef4aSSaravana Kannan * - NULL if no phandle found at index 1243a436ef4aSSaravana Kannan */ 1244a436ef4aSSaravana Kannan static struct device_node *parse_suffix_prop_cells(struct device_node *np, 1245a436ef4aSSaravana Kannan const char *prop_name, int index, 1246a436ef4aSSaravana Kannan const char *suffix, 1247a436ef4aSSaravana Kannan const char *cells_name) 1248a3e1d1a7SSaravana Kannan { 1249a436ef4aSSaravana Kannan struct of_phandle_args sup_args; 1250a436ef4aSSaravana Kannan 1251a436ef4aSSaravana Kannan if (strcmp_suffix(prop_name, suffix)) 1252a3e1d1a7SSaravana Kannan return NULL; 1253a3e1d1a7SSaravana Kannan 1254a436ef4aSSaravana Kannan if (of_parse_phandle_with_args(np, prop_name, cells_name, index, 1255a436ef4aSSaravana Kannan &sup_args)) 1256a436ef4aSSaravana Kannan return NULL; 1257a436ef4aSSaravana Kannan 1258a436ef4aSSaravana Kannan return sup_args.np; 1259a436ef4aSSaravana Kannan } 1260a436ef4aSSaravana Kannan 1261a436ef4aSSaravana Kannan #define DEFINE_SUFFIX_PROP(fname, suffix, cells) \ 1262a436ef4aSSaravana Kannan static struct device_node *parse_##fname(struct device_node *np, \ 1263a436ef4aSSaravana Kannan const char *prop_name, int index) \ 1264a436ef4aSSaravana Kannan { \ 1265a436ef4aSSaravana Kannan return parse_suffix_prop_cells(np, prop_name, index, suffix, cells); \ 1266a3e1d1a7SSaravana Kannan } 1267a3e1d1a7SSaravana Kannan 1268a3e1d1a7SSaravana Kannan /** 1269a3e1d1a7SSaravana Kannan * struct supplier_bindings - Property parsing functions for suppliers 1270a3e1d1a7SSaravana Kannan * 1271a3e1d1a7SSaravana Kannan * @parse_prop: function name 1272a3e1d1a7SSaravana Kannan * parse_prop() finds the node corresponding to a supplier phandle 1273a3e1d1a7SSaravana Kannan * @parse_prop.np: Pointer to device node holding supplier phandle property 1274a3e1d1a7SSaravana Kannan * @parse_prop.prop_name: Name of property holding a phandle value 1275a3e1d1a7SSaravana Kannan * @parse_prop.index: For properties holding a list of phandles, this is the 1276a3e1d1a7SSaravana Kannan * index into the list 12773915fed9SLee Jones * @optional: Describes whether a supplier is mandatory or not 12783cd6bab2SUlf Hansson * @node_not_dev: The consumer node containing the property is never converted 12793cd6bab2SUlf Hansson * to a struct device. Instead, parse ancestor nodes for the 12803cd6bab2SUlf Hansson * compatible property to find a node corresponding to a device. 1281a3e1d1a7SSaravana Kannan * 1282a3e1d1a7SSaravana Kannan * Returns: 1283a3e1d1a7SSaravana Kannan * parse_prop() return values are 1284a3e1d1a7SSaravana Kannan * - phandle node pointer with refcount incremented. Caller must of_node_put() 1285a3e1d1a7SSaravana Kannan * on it when done. 1286a3e1d1a7SSaravana Kannan * - NULL if no phandle found at index 1287a3e1d1a7SSaravana Kannan */ 1288a3e1d1a7SSaravana Kannan struct supplier_bindings { 1289a3e1d1a7SSaravana Kannan struct device_node *(*parse_prop)(struct device_node *np, 1290a3e1d1a7SSaravana Kannan const char *prop_name, int index); 1291a9dd8f3cSSaravana Kannan bool optional; 1292f7514a66SSaravana Kannan bool node_not_dev; 1293a3e1d1a7SSaravana Kannan }; 1294a3e1d1a7SSaravana Kannan 1295a436ef4aSSaravana Kannan DEFINE_SIMPLE_PROP(clocks, "clocks", "#clock-cells") 1296a436ef4aSSaravana Kannan DEFINE_SIMPLE_PROP(interconnects, "interconnects", "#interconnect-cells") 12978e12257dSSaravana Kannan DEFINE_SIMPLE_PROP(iommus, "iommus", "#iommu-cells") 12988e12257dSSaravana Kannan DEFINE_SIMPLE_PROP(mboxes, "mboxes", "#mbox-cells") 12998e12257dSSaravana Kannan DEFINE_SIMPLE_PROP(io_channels, "io-channel", "#io-channel-cells") 13007f00be96SSaravana Kannan DEFINE_SIMPLE_PROP(interrupt_parent, "interrupt-parent", NULL) 13017f00be96SSaravana Kannan DEFINE_SIMPLE_PROP(dmas, "dmas", "#dma-cells") 13022f7afc34SSaravana Kannan DEFINE_SIMPLE_PROP(power_domains, "power-domains", "#power-domain-cells") 13032f7afc34SSaravana Kannan DEFINE_SIMPLE_PROP(hwlocks, "hwlocks", "#hwlock-cells") 130478056e70SSaravana Kannan DEFINE_SIMPLE_PROP(extcon, "extcon", NULL) 130553e6a671SSaravana Kannan DEFINE_SIMPLE_PROP(nvmem_cells, "nvmem-cells", NULL) 130653e6a671SSaravana Kannan DEFINE_SIMPLE_PROP(phys, "phys", "#phy-cells") 130753e6a671SSaravana Kannan DEFINE_SIMPLE_PROP(wakeup_parent, "wakeup-parent", NULL) 1308fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl0, "pinctrl-0", NULL) 1309fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl1, "pinctrl-1", NULL) 1310fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl2, "pinctrl-2", NULL) 1311fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl3, "pinctrl-3", NULL) 1312fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl4, "pinctrl-4", NULL) 1313fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl5, "pinctrl-5", NULL) 1314fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl6, "pinctrl-6", NULL) 1315fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl7, "pinctrl-7", NULL) 1316fb820b49SSaravana Kannan DEFINE_SIMPLE_PROP(pinctrl8, "pinctrl-8", NULL) 1317f7514a66SSaravana Kannan DEFINE_SIMPLE_PROP(remote_endpoint, "remote-endpoint", NULL) 13186b2117adSSaravana Kannan DEFINE_SIMPLE_PROP(pwms, "pwms", "#pwm-cells") 13196b2117adSSaravana Kannan DEFINE_SIMPLE_PROP(resets, "resets", "#reset-cells") 132018c585c7SSaravana Kannan DEFINE_SIMPLE_PROP(leds, "leds", NULL) 132118c585c7SSaravana Kannan DEFINE_SIMPLE_PROP(backlight, "backlight", NULL) 1322a436ef4aSSaravana Kannan DEFINE_SUFFIX_PROP(regulators, "-supply", NULL) 13237f00be96SSaravana Kannan DEFINE_SUFFIX_PROP(gpio, "-gpio", "#gpio-cells") 1324d473d32cSIlya Lipnitskiy 1325d473d32cSIlya Lipnitskiy static struct device_node *parse_gpios(struct device_node *np, 1326d473d32cSIlya Lipnitskiy const char *prop_name, int index) 1327d473d32cSIlya Lipnitskiy { 1328d473d32cSIlya Lipnitskiy if (!strcmp_suffix(prop_name, ",nr-gpios")) 1329d473d32cSIlya Lipnitskiy return NULL; 1330d473d32cSIlya Lipnitskiy 1331d473d32cSIlya Lipnitskiy return parse_suffix_prop_cells(np, prop_name, index, "-gpios", 1332d473d32cSIlya Lipnitskiy "#gpio-cells"); 1333d473d32cSIlya Lipnitskiy } 1334a436ef4aSSaravana Kannan 1335e149573bSWill Deacon static struct device_node *parse_iommu_maps(struct device_node *np, 1336e149573bSWill Deacon const char *prop_name, int index) 1337e149573bSWill Deacon { 1338e149573bSWill Deacon if (strcmp(prop_name, "iommu-map")) 1339e149573bSWill Deacon return NULL; 1340e149573bSWill Deacon 1341e149573bSWill Deacon return of_parse_phandle(np, prop_name, (index * 4) + 1); 1342e149573bSWill Deacon } 1343e149573bSWill Deacon 1344e13f5b7aSSaravana Kannan static struct device_node *parse_gpio_compat(struct device_node *np, 1345e13f5b7aSSaravana Kannan const char *prop_name, int index) 1346e13f5b7aSSaravana Kannan { 1347e13f5b7aSSaravana Kannan struct of_phandle_args sup_args; 1348e13f5b7aSSaravana Kannan 1349e13f5b7aSSaravana Kannan if (strcmp(prop_name, "gpio") && strcmp(prop_name, "gpios")) 1350e13f5b7aSSaravana Kannan return NULL; 1351e13f5b7aSSaravana Kannan 1352e13f5b7aSSaravana Kannan /* 1353e13f5b7aSSaravana Kannan * Ignore node with gpio-hog property since its gpios are all provided 1354e13f5b7aSSaravana Kannan * by its parent. 1355e13f5b7aSSaravana Kannan */ 1356e13f5b7aSSaravana Kannan if (of_find_property(np, "gpio-hog", NULL)) 1357e13f5b7aSSaravana Kannan return NULL; 1358e13f5b7aSSaravana Kannan 1359e13f5b7aSSaravana Kannan if (of_parse_phandle_with_args(np, prop_name, "#gpio-cells", index, 1360e13f5b7aSSaravana Kannan &sup_args)) 1361e13f5b7aSSaravana Kannan return NULL; 1362e13f5b7aSSaravana Kannan 1363e13f5b7aSSaravana Kannan return sup_args.np; 1364e13f5b7aSSaravana Kannan } 1365e13f5b7aSSaravana Kannan 13664104ca77SSaravana Kannan static struct device_node *parse_interrupts(struct device_node *np, 13674104ca77SSaravana Kannan const char *prop_name, int index) 13684104ca77SSaravana Kannan { 1369f265f06aSSaravana Kannan struct of_phandle_args sup_args; 1370f265f06aSSaravana Kannan 1371bd6d617aSSaravana Kannan if (!IS_ENABLED(CONFIG_OF_IRQ) || IS_ENABLED(CONFIG_PPC)) 1372bd6d617aSSaravana Kannan return NULL; 1373bd6d617aSSaravana Kannan 1374f265f06aSSaravana Kannan if (strcmp(prop_name, "interrupts") && 1375f265f06aSSaravana Kannan strcmp(prop_name, "interrupts-extended")) 13764104ca77SSaravana Kannan return NULL; 13774104ca77SSaravana Kannan 1378f265f06aSSaravana Kannan return of_irq_parse_one(np, index, &sup_args) ? NULL : sup_args.np; 13794104ca77SSaravana Kannan } 13804104ca77SSaravana Kannan 1381af1b967aSSaravana Kannan static const struct supplier_bindings of_supplier_bindings[] = { 1382a3e1d1a7SSaravana Kannan { .parse_prop = parse_clocks, }, 1383a3e1d1a7SSaravana Kannan { .parse_prop = parse_interconnects, }, 1384a9dd8f3cSSaravana Kannan { .parse_prop = parse_iommus, .optional = true, }, 1385a9dd8f3cSSaravana Kannan { .parse_prop = parse_iommu_maps, .optional = true, }, 13868e12257dSSaravana Kannan { .parse_prop = parse_mboxes, }, 13878e12257dSSaravana Kannan { .parse_prop = parse_io_channels, }, 13887f00be96SSaravana Kannan { .parse_prop = parse_interrupt_parent, }, 1389a9dd8f3cSSaravana Kannan { .parse_prop = parse_dmas, .optional = true, }, 13902f7afc34SSaravana Kannan { .parse_prop = parse_power_domains, }, 13912f7afc34SSaravana Kannan { .parse_prop = parse_hwlocks, }, 139278056e70SSaravana Kannan { .parse_prop = parse_extcon, }, 139353e6a671SSaravana Kannan { .parse_prop = parse_nvmem_cells, }, 139453e6a671SSaravana Kannan { .parse_prop = parse_phys, }, 139553e6a671SSaravana Kannan { .parse_prop = parse_wakeup_parent, }, 1396fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl0, }, 1397fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl1, }, 1398fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl2, }, 1399fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl3, }, 1400fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl4, }, 1401fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl5, }, 1402fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl6, }, 1403fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl7, }, 1404fb820b49SSaravana Kannan { .parse_prop = parse_pinctrl8, }, 1405f7514a66SSaravana Kannan { .parse_prop = parse_remote_endpoint, .node_not_dev = true, }, 14066b2117adSSaravana Kannan { .parse_prop = parse_pwms, }, 14076b2117adSSaravana Kannan { .parse_prop = parse_resets, }, 140818c585c7SSaravana Kannan { .parse_prop = parse_leds, }, 140918c585c7SSaravana Kannan { .parse_prop = parse_backlight, }, 1410e13f5b7aSSaravana Kannan { .parse_prop = parse_gpio_compat, }, 14114104ca77SSaravana Kannan { .parse_prop = parse_interrupts, }, 1412a3e1d1a7SSaravana Kannan { .parse_prop = parse_regulators, }, 14137f00be96SSaravana Kannan { .parse_prop = parse_gpio, }, 14147f00be96SSaravana Kannan { .parse_prop = parse_gpios, }, 1415af1b967aSSaravana Kannan {} 1416a3e1d1a7SSaravana Kannan }; 1417a3e1d1a7SSaravana Kannan 1418a3e1d1a7SSaravana Kannan /** 1419a3e1d1a7SSaravana Kannan * of_link_property - Create device links to suppliers listed in a property 1420a3e1d1a7SSaravana Kannan * @con_np: The consumer device tree node which contains the property 1421a3e1d1a7SSaravana Kannan * @prop_name: Name of property to be parsed 1422a3e1d1a7SSaravana Kannan * 1423a3e1d1a7SSaravana Kannan * This function checks if the property @prop_name that is present in the 1424a3e1d1a7SSaravana Kannan * @con_np device tree node is one of the known common device tree bindings 1425a3e1d1a7SSaravana Kannan * that list phandles to suppliers. If @prop_name isn't one, this function 1426a3e1d1a7SSaravana Kannan * doesn't do anything. 1427a3e1d1a7SSaravana Kannan * 14288a06d1eaSSaravana Kannan * If @prop_name is one, this function attempts to create fwnode links from the 14298a06d1eaSSaravana Kannan * consumer device tree node @con_np to all the suppliers device tree nodes 14308a06d1eaSSaravana Kannan * listed in @prop_name. 1431a3e1d1a7SSaravana Kannan * 14328a06d1eaSSaravana Kannan * Any failed attempt to create a fwnode link will NOT result in an immediate 1433a3e1d1a7SSaravana Kannan * return. of_link_property() must create links to all the available supplier 14348a06d1eaSSaravana Kannan * device tree nodes even when attempts to create a link to one or more 14358a06d1eaSSaravana Kannan * suppliers fail. 1436a3e1d1a7SSaravana Kannan */ 14378a06d1eaSSaravana Kannan static int of_link_property(struct device_node *con_np, const char *prop_name) 1438a3e1d1a7SSaravana Kannan { 1439a3e1d1a7SSaravana Kannan struct device_node *phandle; 1440af1b967aSSaravana Kannan const struct supplier_bindings *s = of_supplier_bindings; 1441a3e1d1a7SSaravana Kannan unsigned int i = 0; 1442a3e1d1a7SSaravana Kannan bool matched = false; 1443a3e1d1a7SSaravana Kannan 1444a3e1d1a7SSaravana Kannan /* Do not stop at first failed link, link all available suppliers. */ 1445a3e1d1a7SSaravana Kannan while (!matched && s->parse_prop) { 1446a9dd8f3cSSaravana Kannan if (s->optional && !fw_devlink_is_strict()) { 1447a9dd8f3cSSaravana Kannan s++; 1448a9dd8f3cSSaravana Kannan continue; 1449a9dd8f3cSSaravana Kannan } 1450a9dd8f3cSSaravana Kannan 1451a3e1d1a7SSaravana Kannan while ((phandle = s->parse_prop(con_np, prop_name, i))) { 1452f7514a66SSaravana Kannan struct device_node *con_dev_np; 1453f7514a66SSaravana Kannan 1454f7514a66SSaravana Kannan con_dev_np = s->node_not_dev 14553cd6bab2SUlf Hansson ? of_get_compat_node_parent(con_np) 1456f7514a66SSaravana Kannan : of_node_get(con_np); 1457a3e1d1a7SSaravana Kannan matched = true; 1458a3e1d1a7SSaravana Kannan i++; 1459f7514a66SSaravana Kannan of_link_to_phandle(con_dev_np, phandle); 1460a3e1d1a7SSaravana Kannan of_node_put(phandle); 1461f7514a66SSaravana Kannan of_node_put(con_dev_np); 1462a3e1d1a7SSaravana Kannan } 1463a3e1d1a7SSaravana Kannan s++; 1464a3e1d1a7SSaravana Kannan } 1465065cac6cSYang Li return 0; 1466a3e1d1a7SSaravana Kannan } 1467a3e1d1a7SSaravana Kannan 146868b979d0SSakari Ailus static void __iomem *of_fwnode_iomap(struct fwnode_handle *fwnode, int index) 146968b979d0SSakari Ailus { 147068b979d0SSakari Ailus #ifdef CONFIG_OF_ADDRESS 147168b979d0SSakari Ailus return of_iomap(to_of_node(fwnode), index); 147268b979d0SSakari Ailus #else 147368b979d0SSakari Ailus return NULL; 147468b979d0SSakari Ailus #endif 147568b979d0SSakari Ailus } 147668b979d0SSakari Ailus 1477*99c63707SSakari Ailus static int of_fwnode_irq_get(const struct fwnode_handle *fwnode, 1478*99c63707SSakari Ailus unsigned int index) 1479*99c63707SSakari Ailus { 1480*99c63707SSakari Ailus return of_irq_get(to_of_node(fwnode), index); 1481*99c63707SSakari Ailus } 1482*99c63707SSakari Ailus 14832d09e6ebSSaravana Kannan static int of_fwnode_add_links(struct fwnode_handle *fwnode) 1484a3e1d1a7SSaravana Kannan { 14858a06d1eaSSaravana Kannan struct property *p; 14868a06d1eaSSaravana Kannan struct device_node *con_np = to_of_node(fwnode); 1487a3e1d1a7SSaravana Kannan 14884a48b66bSSaravana Kannan if (IS_ENABLED(CONFIG_X86)) 14894a48b66bSSaravana Kannan return 0; 14904a48b66bSSaravana Kannan 14918a06d1eaSSaravana Kannan if (!con_np) 14928a06d1eaSSaravana Kannan return -EINVAL; 14938a06d1eaSSaravana Kannan 14948a06d1eaSSaravana Kannan for_each_property_of_node(con_np, p) 14958a06d1eaSSaravana Kannan of_link_property(con_np, p->name); 14968a06d1eaSSaravana Kannan 14978a06d1eaSSaravana Kannan return 0; 1498a3e1d1a7SSaravana Kannan } 1499a3e1d1a7SSaravana Kannan 15003708184aSSakari Ailus const struct fwnode_operations of_fwnode_ops = { 15013708184aSSakari Ailus .get = of_fwnode_get, 15023708184aSSakari Ailus .put = of_fwnode_put, 15032294b3afSSakari Ailus .device_is_available = of_fwnode_device_is_available, 15041c2c82eaSSinan Kaya .device_get_match_data = of_fwnode_device_get_match_data, 15058c756a0aSSakari Ailus .device_dma_supported = of_fwnode_device_dma_supported, 15068c756a0aSSakari Ailus .device_get_dma_attr = of_fwnode_device_get_dma_attr, 15073708184aSSakari Ailus .property_present = of_fwnode_property_present, 15083708184aSSakari Ailus .property_read_int_array = of_fwnode_property_read_int_array, 15093708184aSSakari Ailus .property_read_string_array = of_fwnode_property_read_string_array, 1510bc0500c1SSakari Ailus .get_name = of_fwnode_get_name, 1511e7e242bcSSakari Ailus .get_name_prefix = of_fwnode_get_name_prefix, 15123708184aSSakari Ailus .get_parent = of_fwnode_get_parent, 15133708184aSSakari Ailus .get_next_child_node = of_fwnode_get_next_child_node, 15143708184aSSakari Ailus .get_named_child_node = of_fwnode_get_named_child_node, 15153e3119d3SSakari Ailus .get_reference_args = of_fwnode_get_reference_args, 15163b27d00eSSakari Ailus .graph_get_next_endpoint = of_fwnode_graph_get_next_endpoint, 15173b27d00eSSakari Ailus .graph_get_remote_endpoint = of_fwnode_graph_get_remote_endpoint, 15183b27d00eSSakari Ailus .graph_get_port_parent = of_fwnode_graph_get_port_parent, 15193b27d00eSSakari Ailus .graph_parse_endpoint = of_fwnode_graph_parse_endpoint, 152068b979d0SSakari Ailus .iomap = of_fwnode_iomap, 1521*99c63707SSakari Ailus .irq_get = of_fwnode_irq_get, 1522a3e1d1a7SSaravana Kannan .add_links = of_fwnode_add_links, 15233708184aSSakari Ailus }; 1524db3e50f3SSakari Ailus EXPORT_SYMBOL_GPL(of_fwnode_ops); 1525