LCOV - code coverage report
Current view: top level - include/linux - of.h (source / functions) Hit Total Coverage
Test: Real Lines: 23 42 54.8 %
Date: 2020-10-17 15:46:16 Functions: 0 3 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0+ */
       2                 :            : #ifndef _LINUX_OF_H
       3                 :            : #define _LINUX_OF_H
       4                 :            : /*
       5                 :            :  * Definitions for talking to the Open Firmware PROM on
       6                 :            :  * Power Macintosh and other computers.
       7                 :            :  *
       8                 :            :  * Copyright (C) 1996-2005 Paul Mackerras.
       9                 :            :  *
      10                 :            :  * Updates for PPC64 by Peter Bergner & David Engebretsen, IBM Corp.
      11                 :            :  * Updates for SPARC64 by David S. Miller
      12                 :            :  * Derived from PowerPC and Sparc prom.h files by Stephen Rothwell, IBM Corp.
      13                 :            :  */
      14                 :            : #include <linux/types.h>
      15                 :            : #include <linux/bitops.h>
      16                 :            : #include <linux/errno.h>
      17                 :            : #include <linux/kobject.h>
      18                 :            : #include <linux/mod_devicetable.h>
      19                 :            : #include <linux/spinlock.h>
      20                 :            : #include <linux/topology.h>
      21                 :            : #include <linux/notifier.h>
      22                 :            : #include <linux/property.h>
      23                 :            : #include <linux/list.h>
      24                 :            : 
      25                 :            : #include <asm/byteorder.h>
      26                 :            : #include <asm/errno.h>
      27                 :            : 
      28                 :            : typedef u32 phandle;
      29                 :            : typedef u32 ihandle;
      30                 :            : 
      31                 :            : struct property {
      32                 :            :         char    *name;
      33                 :            :         int     length;
      34                 :            :         void    *value;
      35                 :            :         struct property *next;
      36                 :            : #if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
      37                 :            :         unsigned long _flags;
      38                 :            : #endif
      39                 :            : #if defined(CONFIG_OF_PROMTREE)
      40                 :            :         unsigned int unique_id;
      41                 :            : #endif
      42                 :            : #if defined(CONFIG_OF_KOBJ)
      43                 :            :         struct bin_attribute attr;
      44                 :            : #endif
      45                 :            : };
      46                 :            : 
      47                 :            : #if defined(CONFIG_SPARC)
      48                 :            : struct of_irq_controller;
      49                 :            : #endif
      50                 :            : 
      51                 :            : struct device_node {
      52                 :            :         const char *name;
      53                 :            :         phandle phandle;
      54                 :            :         const char *full_name;
      55                 :            :         struct fwnode_handle fwnode;
      56                 :            : 
      57                 :            :         struct  property *properties;
      58                 :            :         struct  property *deadprops;    /* removed properties */
      59                 :            :         struct  device_node *parent;
      60                 :            :         struct  device_node *child;
      61                 :            :         struct  device_node *sibling;
      62                 :            : #if defined(CONFIG_OF_KOBJ)
      63                 :            :         struct  kobject kobj;
      64                 :            : #endif
      65                 :            :         unsigned long _flags;
      66                 :            :         void    *data;
      67                 :            : #if defined(CONFIG_SPARC)
      68                 :            :         unsigned int unique_id;
      69                 :            :         struct of_irq_controller *irq_trans;
      70                 :            : #endif
      71                 :            : };
      72                 :            : 
      73                 :            : #define MAX_PHANDLE_ARGS 16
      74                 :            : struct of_phandle_args {
      75                 :            :         struct device_node *np;
      76                 :            :         int args_count;
      77                 :            :         uint32_t args[MAX_PHANDLE_ARGS];
      78                 :            : };
      79                 :            : 
      80                 :            : struct of_phandle_iterator {
      81                 :            :         /* Common iterator information */
      82                 :            :         const char *cells_name;
      83                 :            :         int cell_count;
      84                 :            :         const struct device_node *parent;
      85                 :            : 
      86                 :            :         /* List size information */
      87                 :            :         const __be32 *list_end;
      88                 :            :         const __be32 *phandle_end;
      89                 :            : 
      90                 :            :         /* Current position state */
      91                 :            :         const __be32 *cur;
      92                 :            :         uint32_t cur_count;
      93                 :            :         phandle phandle;
      94                 :            :         struct device_node *node;
      95                 :            : };
      96                 :            : 
      97                 :            : struct of_reconfig_data {
      98                 :            :         struct device_node      *dn;
      99                 :            :         struct property         *prop;
     100                 :            :         struct property         *old_prop;
     101                 :            : };
     102                 :            : 
     103                 :            : /* initialize a node */
     104                 :            : extern struct kobj_type of_node_ktype;
     105                 :            : extern const struct fwnode_operations of_fwnode_ops;
     106                 :            : static inline void of_node_init(struct device_node *node)
     107                 :            : {
     108                 :            : #if defined(CONFIG_OF_KOBJ)
     109                 :          3 :         kobject_init(&node->kobj, &of_node_ktype);
     110                 :            : #endif
     111                 :          3 :         node->fwnode.ops = &of_fwnode_ops;
     112                 :            : }
     113                 :            : 
     114                 :            : #if defined(CONFIG_OF_KOBJ)
     115                 :            : #define of_node_kobj(n) (&(n)->kobj)
     116                 :            : #else
     117                 :            : #define of_node_kobj(n) NULL
     118                 :            : #endif
     119                 :            : 
     120                 :            : #ifdef CONFIG_OF_DYNAMIC
     121                 :            : extern struct device_node *of_node_get(struct device_node *node);
     122                 :            : extern void of_node_put(struct device_node *node);
     123                 :            : #else /* CONFIG_OF_DYNAMIC */
     124                 :            : /* Dummy ref counting routines - to be implemented later */
     125                 :            : static inline struct device_node *of_node_get(struct device_node *node)
     126                 :            : {
     127                 :            :         return node;
     128                 :            : }
     129                 :            : static inline void of_node_put(struct device_node *node) { }
     130                 :            : #endif /* !CONFIG_OF_DYNAMIC */
     131                 :            : 
     132                 :            : /* Pointer for first entry in chain of all nodes. */
     133                 :            : extern struct device_node *of_root;
     134                 :            : extern struct device_node *of_chosen;
     135                 :            : extern struct device_node *of_aliases;
     136                 :            : extern struct device_node *of_stdout;
     137                 :            : extern raw_spinlock_t devtree_lock;
     138                 :            : 
     139                 :            : /*
     140                 :            :  * struct device_node flag descriptions
     141                 :            :  * (need to be visible even when !CONFIG_OF)
     142                 :            :  */
     143                 :            : #define OF_DYNAMIC              1 /* (and properties) allocated via kmalloc */
     144                 :            : #define OF_DETACHED             2 /* detached from the device tree */
     145                 :            : #define OF_POPULATED            3 /* device already created */
     146                 :            : #define OF_POPULATED_BUS        4 /* platform bus created for children */
     147                 :            : #define OF_OVERLAY              5 /* allocated for an overlay */
     148                 :            : #define OF_OVERLAY_FREE_CSET    6 /* in overlay cset being freed */
     149                 :            : 
     150                 :            : #define OF_BAD_ADDR     ((u64)-1)
     151                 :            : 
     152                 :            : #ifdef CONFIG_OF
     153                 :            : void of_core_init(void);
     154                 :            : 
     155                 :            : static inline bool is_of_node(const struct fwnode_handle *fwnode)
     156                 :            : {
     157                 :          3 :         return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &of_fwnode_ops;
     158                 :            : }
     159                 :            : 
     160                 :            : #define to_of_node(__fwnode)                                            \
     161                 :            :         ({                                                              \
     162                 :            :                 typeof(__fwnode) __to_of_node_fwnode = (__fwnode);      \
     163                 :            :                                                                         \
     164                 :            :                 is_of_node(__to_of_node_fwnode) ?                       \
     165                 :            :                         container_of(__to_of_node_fwnode,               \
     166                 :            :                                      struct device_node, fwnode) :      \
     167                 :            :                         NULL;                                           \
     168                 :            :         })
     169                 :            : 
     170                 :            : #define of_fwnode_handle(node)                                          \
     171                 :            :         ({                                                              \
     172                 :            :                 typeof(node) __of_fwnode_handle_node = (node);          \
     173                 :            :                                                                         \
     174                 :            :                 __of_fwnode_handle_node ?                               \
     175                 :            :                         &__of_fwnode_handle_node->fwnode : NULL; \
     176                 :            :         })
     177                 :            : 
     178                 :            : static inline bool of_have_populated_dt(void)
     179                 :            : {
     180                 :          3 :         return of_root != NULL;
     181                 :            : }
     182                 :            : 
     183                 :            : static inline bool of_node_is_root(const struct device_node *node)
     184                 :            : {
     185                 :          3 :         return node && (node->parent == NULL);
     186                 :            : }
     187                 :            : 
     188                 :            : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
     189                 :            : {
     190                 :            :         return test_bit(flag, &n->_flags);
     191                 :            : }
     192                 :            : 
     193                 :            : static inline int of_node_test_and_set_flag(struct device_node *n,
     194                 :            :                                             unsigned long flag)
     195                 :            : {
     196                 :          3 :         return test_and_set_bit(flag, &n->_flags);
     197                 :            : }
     198                 :            : 
     199                 :            : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
     200                 :            : {
     201                 :          3 :         set_bit(flag, &n->_flags);
     202                 :            : }
     203                 :            : 
     204                 :            : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
     205                 :            : {
     206                 :          0 :         clear_bit(flag, &n->_flags);
     207                 :            : }
     208                 :            : 
     209                 :            : #if defined(CONFIG_OF_DYNAMIC) || defined(CONFIG_SPARC)
     210                 :            : static inline int of_property_check_flag(struct property *p, unsigned long flag)
     211                 :            : {
     212                 :            :         return test_bit(flag, &p->_flags);
     213                 :            : }
     214                 :            : 
     215                 :            : static inline void of_property_set_flag(struct property *p, unsigned long flag)
     216                 :            : {
     217                 :          0 :         set_bit(flag, &p->_flags);
     218                 :            : }
     219                 :            : 
     220                 :            : static inline void of_property_clear_flag(struct property *p, unsigned long flag)
     221                 :            : {
     222                 :            :         clear_bit(flag, &p->_flags);
     223                 :            : }
     224                 :            : #endif
     225                 :            : 
     226                 :            : extern struct device_node *__of_find_all_nodes(struct device_node *prev);
     227                 :            : extern struct device_node *of_find_all_nodes(struct device_node *prev);
     228                 :            : 
     229                 :            : /*
     230                 :            :  * OF address retrieval & translation
     231                 :            :  */
     232                 :            : 
     233                 :            : /* Helper to read a big number; size is in cells (not bytes) */
     234                 :            : static inline u64 of_read_number(const __be32 *cell, int size)
     235                 :            : {
     236                 :            :         u64 r = 0;
     237                 :          3 :         for (; size--; cell++)
     238                 :          3 :                 r = (r << 32) | be32_to_cpu(*cell);
     239                 :          3 :         return r;
     240                 :            : }
     241                 :            : 
     242                 :            : /* Like of_read_number, but we want an unsigned long result */
     243                 :            : static inline unsigned long of_read_ulong(const __be32 *cell, int size)
     244                 :            : {
     245                 :            :         /* toss away upper bits if unsigned long is smaller than u64 */
     246                 :          3 :         return of_read_number(cell, size);
     247                 :            : }
     248                 :            : 
     249                 :            : #if defined(CONFIG_SPARC)
     250                 :            : #include <asm/prom.h>
     251                 :            : #endif
     252                 :            : 
     253                 :            : #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
     254                 :            : #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
     255                 :            : 
     256                 :            : extern bool of_node_name_eq(const struct device_node *np, const char *name);
     257                 :            : extern bool of_node_name_prefix(const struct device_node *np, const char *prefix);
     258                 :            : 
     259                 :            : static inline const char *of_node_full_name(const struct device_node *np)
     260                 :            : {
     261                 :          3 :         return np ? np->full_name : "<no-node>";
     262                 :            : }
     263                 :            : 
     264                 :            : #define for_each_of_allnodes_from(from, dn) \
     265                 :            :         for (dn = __of_find_all_nodes(from); dn; dn = __of_find_all_nodes(dn))
     266                 :            : #define for_each_of_allnodes(dn) for_each_of_allnodes_from(NULL, dn)
     267                 :            : extern struct device_node *of_find_node_by_name(struct device_node *from,
     268                 :            :         const char *name);
     269                 :            : extern struct device_node *of_find_node_by_type(struct device_node *from,
     270                 :            :         const char *type);
     271                 :            : extern struct device_node *of_find_compatible_node(struct device_node *from,
     272                 :            :         const char *type, const char *compat);
     273                 :            : extern struct device_node *of_find_matching_node_and_match(
     274                 :            :         struct device_node *from,
     275                 :            :         const struct of_device_id *matches,
     276                 :            :         const struct of_device_id **match);
     277                 :            : 
     278                 :            : extern struct device_node *of_find_node_opts_by_path(const char *path,
     279                 :            :         const char **opts);
     280                 :          0 : static inline struct device_node *of_find_node_by_path(const char *path)
     281                 :            : {
     282                 :          3 :         return of_find_node_opts_by_path(path, NULL);
     283                 :            : }
     284                 :            : 
     285                 :            : extern struct device_node *of_find_node_by_phandle(phandle handle);
     286                 :            : extern struct device_node *of_get_parent(const struct device_node *node);
     287                 :            : extern struct device_node *of_get_next_parent(struct device_node *node);
     288                 :            : extern struct device_node *of_get_next_child(const struct device_node *node,
     289                 :            :                                              struct device_node *prev);
     290                 :            : extern struct device_node *of_get_next_available_child(
     291                 :            :         const struct device_node *node, struct device_node *prev);
     292                 :            : 
     293                 :            : extern struct device_node *of_get_compatible_child(const struct device_node *parent,
     294                 :            :                                         const char *compatible);
     295                 :            : extern struct device_node *of_get_child_by_name(const struct device_node *node,
     296                 :            :                                         const char *name);
     297                 :            : 
     298                 :            : /* cache lookup */
     299                 :            : extern struct device_node *of_find_next_cache_node(const struct device_node *);
     300                 :            : extern int of_find_last_cache_level(unsigned int cpu);
     301                 :            : extern struct device_node *of_find_node_with_property(
     302                 :            :         struct device_node *from, const char *prop_name);
     303                 :            : 
     304                 :            : extern struct property *of_find_property(const struct device_node *np,
     305                 :            :                                          const char *name,
     306                 :            :                                          int *lenp);
     307                 :            : extern int of_property_count_elems_of_size(const struct device_node *np,
     308                 :            :                                 const char *propname, int elem_size);
     309                 :            : extern int of_property_read_u32_index(const struct device_node *np,
     310                 :            :                                        const char *propname,
     311                 :            :                                        u32 index, u32 *out_value);
     312                 :            : extern int of_property_read_u64_index(const struct device_node *np,
     313                 :            :                                        const char *propname,
     314                 :            :                                        u32 index, u64 *out_value);
     315                 :            : extern int of_property_read_variable_u8_array(const struct device_node *np,
     316                 :            :                                         const char *propname, u8 *out_values,
     317                 :            :                                         size_t sz_min, size_t sz_max);
     318                 :            : extern int of_property_read_variable_u16_array(const struct device_node *np,
     319                 :            :                                         const char *propname, u16 *out_values,
     320                 :            :                                         size_t sz_min, size_t sz_max);
     321                 :            : extern int of_property_read_variable_u32_array(const struct device_node *np,
     322                 :            :                                         const char *propname,
     323                 :            :                                         u32 *out_values,
     324                 :            :                                         size_t sz_min,
     325                 :            :                                         size_t sz_max);
     326                 :            : extern int of_property_read_u64(const struct device_node *np,
     327                 :            :                                 const char *propname, u64 *out_value);
     328                 :            : extern int of_property_read_variable_u64_array(const struct device_node *np,
     329                 :            :                                         const char *propname,
     330                 :            :                                         u64 *out_values,
     331                 :            :                                         size_t sz_min,
     332                 :            :                                         size_t sz_max);
     333                 :            : 
     334                 :            : extern int of_property_read_string(const struct device_node *np,
     335                 :            :                                    const char *propname,
     336                 :            :                                    const char **out_string);
     337                 :            : extern int of_property_match_string(const struct device_node *np,
     338                 :            :                                     const char *propname,
     339                 :            :                                     const char *string);
     340                 :            : extern int of_property_read_string_helper(const struct device_node *np,
     341                 :            :                                               const char *propname,
     342                 :            :                                               const char **out_strs, size_t sz, int index);
     343                 :            : extern int of_device_is_compatible(const struct device_node *device,
     344                 :            :                                    const char *);
     345                 :            : extern int of_device_compatible_match(struct device_node *device,
     346                 :            :                                       const char *const *compat);
     347                 :            : extern bool of_device_is_available(const struct device_node *device);
     348                 :            : extern bool of_device_is_big_endian(const struct device_node *device);
     349                 :            : extern const void *of_get_property(const struct device_node *node,
     350                 :            :                                 const char *name,
     351                 :            :                                 int *lenp);
     352                 :            : extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
     353                 :            : extern struct device_node *of_get_next_cpu_node(struct device_node *prev);
     354                 :            : 
     355                 :            : #define for_each_property_of_node(dn, pp) \
     356                 :            :         for (pp = dn->properties; pp != NULL; pp = pp->next)
     357                 :            : 
     358                 :            : extern int of_n_addr_cells(struct device_node *np);
     359                 :            : extern int of_n_size_cells(struct device_node *np);
     360                 :            : extern const struct of_device_id *of_match_node(
     361                 :            :         const struct of_device_id *matches, const struct device_node *node);
     362                 :            : extern int of_modalias_node(struct device_node *node, char *modalias, int len);
     363                 :            : extern void of_print_phandle_args(const char *msg, const struct of_phandle_args *args);
     364                 :            : extern struct device_node *of_parse_phandle(const struct device_node *np,
     365                 :            :                                             const char *phandle_name,
     366                 :            :                                             int index);
     367                 :            : extern int of_parse_phandle_with_args(const struct device_node *np,
     368                 :            :         const char *list_name, const char *cells_name, int index,
     369                 :            :         struct of_phandle_args *out_args);
     370                 :            : extern int of_parse_phandle_with_args_map(const struct device_node *np,
     371                 :            :         const char *list_name, const char *stem_name, int index,
     372                 :            :         struct of_phandle_args *out_args);
     373                 :            : extern int of_parse_phandle_with_fixed_args(const struct device_node *np,
     374                 :            :         const char *list_name, int cells_count, int index,
     375                 :            :         struct of_phandle_args *out_args);
     376                 :            : extern int of_count_phandle_with_args(const struct device_node *np,
     377                 :            :         const char *list_name, const char *cells_name);
     378                 :            : 
     379                 :            : /* phandle iterator functions */
     380                 :            : extern int of_phandle_iterator_init(struct of_phandle_iterator *it,
     381                 :            :                                     const struct device_node *np,
     382                 :            :                                     const char *list_name,
     383                 :            :                                     const char *cells_name,
     384                 :            :                                     int cell_count);
     385                 :            : 
     386                 :            : extern int of_phandle_iterator_next(struct of_phandle_iterator *it);
     387                 :            : extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
     388                 :            :                                     uint32_t *args,
     389                 :            :                                     int size);
     390                 :            : 
     391                 :            : extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
     392                 :            : extern int of_alias_get_id(struct device_node *np, const char *stem);
     393                 :            : extern int of_alias_get_highest_id(const char *stem);
     394                 :            : extern int of_alias_get_alias_list(const struct of_device_id *matches,
     395                 :            :                                    const char *stem, unsigned long *bitmap,
     396                 :            :                                    unsigned int nbits);
     397                 :            : 
     398                 :            : extern int of_machine_is_compatible(const char *compat);
     399                 :            : 
     400                 :            : extern int of_add_property(struct device_node *np, struct property *prop);
     401                 :            : extern int of_remove_property(struct device_node *np, struct property *prop);
     402                 :            : extern int of_update_property(struct device_node *np, struct property *newprop);
     403                 :            : 
     404                 :            : /* For updating the device tree at runtime */
     405                 :            : #define OF_RECONFIG_ATTACH_NODE         0x0001
     406                 :            : #define OF_RECONFIG_DETACH_NODE         0x0002
     407                 :            : #define OF_RECONFIG_ADD_PROPERTY        0x0003
     408                 :            : #define OF_RECONFIG_REMOVE_PROPERTY     0x0004
     409                 :            : #define OF_RECONFIG_UPDATE_PROPERTY     0x0005
     410                 :            : 
     411                 :            : extern int of_attach_node(struct device_node *);
     412                 :            : extern int of_detach_node(struct device_node *);
     413                 :            : 
     414                 :            : #define of_match_ptr(_ptr)      (_ptr)
     415                 :            : 
     416                 :            : /**
     417                 :            :  * of_property_read_u8_array - Find and read an array of u8 from a property.
     418                 :            :  *
     419                 :            :  * @np:         device node from which the property value is to be read.
     420                 :            :  * @propname:   name of the property to be searched.
     421                 :            :  * @out_values: pointer to return value, modified only if return value is 0.
     422                 :            :  * @sz:         number of array elements to read
     423                 :            :  *
     424                 :            :  * Search for a property in a device node and read 8-bit value(s) from
     425                 :            :  * it. Returns 0 on success, -EINVAL if the property does not exist,
     426                 :            :  * -ENODATA if property does not have a value, and -EOVERFLOW if the
     427                 :            :  * property data isn't large enough.
     428                 :            :  *
     429                 :            :  * dts entry of array should be like:
     430                 :            :  *      property = /bits/ 8 <0x50 0x60 0x70>;
     431                 :            :  *
     432                 :            :  * The out_values is modified only if a valid u8 value can be decoded.
     433                 :            :  */
     434                 :            : static inline int of_property_read_u8_array(const struct device_node *np,
     435                 :            :                                             const char *propname,
     436                 :            :                                             u8 *out_values, size_t sz)
     437                 :            : {
     438                 :          0 :         int ret = of_property_read_variable_u8_array(np, propname, out_values,
     439                 :            :                                                      sz, 0);
     440                 :          0 :         if (ret >= 0)
     441                 :            :                 return 0;
     442                 :            :         else
     443                 :            :                 return ret;
     444                 :            : }
     445                 :            : 
     446                 :            : /**
     447                 :            :  * of_property_read_u16_array - Find and read an array of u16 from a property.
     448                 :            :  *
     449                 :            :  * @np:         device node from which the property value is to be read.
     450                 :            :  * @propname:   name of the property to be searched.
     451                 :            :  * @out_values: pointer to return value, modified only if return value is 0.
     452                 :            :  * @sz:         number of array elements to read
     453                 :            :  *
     454                 :            :  * Search for a property in a device node and read 16-bit value(s) from
     455                 :            :  * it. Returns 0 on success, -EINVAL if the property does not exist,
     456                 :            :  * -ENODATA if property does not have a value, and -EOVERFLOW if the
     457                 :            :  * property data isn't large enough.
     458                 :            :  *
     459                 :            :  * dts entry of array should be like:
     460                 :            :  *      property = /bits/ 16 <0x5000 0x6000 0x7000>;
     461                 :            :  *
     462                 :            :  * The out_values is modified only if a valid u16 value can be decoded.
     463                 :            :  */
     464                 :            : static inline int of_property_read_u16_array(const struct device_node *np,
     465                 :            :                                              const char *propname,
     466                 :            :                                              u16 *out_values, size_t sz)
     467                 :            : {
     468                 :          0 :         int ret = of_property_read_variable_u16_array(np, propname, out_values,
     469                 :            :                                                       sz, 0);
     470                 :          0 :         if (ret >= 0)
     471                 :            :                 return 0;
     472                 :            :         else
     473                 :            :                 return ret;
     474                 :            : }
     475                 :            : 
     476                 :            : /**
     477                 :            :  * of_property_read_u32_array - Find and read an array of 32 bit integers
     478                 :            :  * from a property.
     479                 :            :  *
     480                 :            :  * @np:         device node from which the property value is to be read.
     481                 :            :  * @propname:   name of the property to be searched.
     482                 :            :  * @out_values: pointer to return value, modified only if return value is 0.
     483                 :            :  * @sz:         number of array elements to read
     484                 :            :  *
     485                 :            :  * Search for a property in a device node and read 32-bit value(s) from
     486                 :            :  * it. Returns 0 on success, -EINVAL if the property does not exist,
     487                 :            :  * -ENODATA if property does not have a value, and -EOVERFLOW if the
     488                 :            :  * property data isn't large enough.
     489                 :            :  *
     490                 :            :  * The out_values is modified only if a valid u32 value can be decoded.
     491                 :            :  */
     492                 :            : static inline int of_property_read_u32_array(const struct device_node *np,
     493                 :            :                                              const char *propname,
     494                 :            :                                              u32 *out_values, size_t sz)
     495                 :            : {
     496                 :          3 :         int ret = of_property_read_variable_u32_array(np, propname, out_values,
     497                 :            :                                                       sz, 0);
     498                 :          3 :         if (ret >= 0)
     499                 :            :                 return 0;
     500                 :            :         else
     501                 :            :                 return ret;
     502                 :            : }
     503                 :            : 
     504                 :            : /**
     505                 :            :  * of_property_read_u64_array - Find and read an array of 64 bit integers
     506                 :            :  * from a property.
     507                 :            :  *
     508                 :            :  * @np:         device node from which the property value is to be read.
     509                 :            :  * @propname:   name of the property to be searched.
     510                 :            :  * @out_values: pointer to return value, modified only if return value is 0.
     511                 :            :  * @sz:         number of array elements to read
     512                 :            :  *
     513                 :            :  * Search for a property in a device node and read 64-bit value(s) from
     514                 :            :  * it. Returns 0 on success, -EINVAL if the property does not exist,
     515                 :            :  * -ENODATA if property does not have a value, and -EOVERFLOW if the
     516                 :            :  * property data isn't large enough.
     517                 :            :  *
     518                 :            :  * The out_values is modified only if a valid u64 value can be decoded.
     519                 :            :  */
     520                 :            : static inline int of_property_read_u64_array(const struct device_node *np,
     521                 :            :                                              const char *propname,
     522                 :            :                                              u64 *out_values, size_t sz)
     523                 :            : {
     524                 :          0 :         int ret = of_property_read_variable_u64_array(np, propname, out_values,
     525                 :            :                                                       sz, 0);
     526                 :          0 :         if (ret >= 0)
     527                 :            :                 return 0;
     528                 :            :         else
     529                 :            :                 return ret;
     530                 :            : }
     531                 :            : 
     532                 :            : /*
     533                 :            :  * struct property *prop;
     534                 :            :  * const __be32 *p;
     535                 :            :  * u32 u;
     536                 :            :  *
     537                 :            :  * of_property_for_each_u32(np, "propname", prop, p, u)
     538                 :            :  *         printk("U32 value: %x\n", u);
     539                 :            :  */
     540                 :            : const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
     541                 :            :                                u32 *pu);
     542                 :            : /*
     543                 :            :  * struct property *prop;
     544                 :            :  * const char *s;
     545                 :            :  *
     546                 :            :  * of_property_for_each_string(np, "propname", prop, s)
     547                 :            :  *         printk("String value: %s\n", s);
     548                 :            :  */
     549                 :            : const char *of_prop_next_string(struct property *prop, const char *cur);
     550                 :            : 
     551                 :            : bool of_console_check(struct device_node *dn, char *name, int index);
     552                 :            : 
     553                 :            : extern int of_cpu_node_to_id(struct device_node *np);
     554                 :            : 
     555                 :            : int of_map_rid(struct device_node *np, u32 rid,
     556                 :            :                const char *map_name, const char *map_mask_name,
     557                 :            :                struct device_node **target, u32 *id_out);
     558                 :            : 
     559                 :            : #else /* CONFIG_OF */
     560                 :            : 
     561                 :            : static inline void of_core_init(void)
     562                 :            : {
     563                 :            : }
     564                 :            : 
     565                 :            : static inline bool is_of_node(const struct fwnode_handle *fwnode)
     566                 :            : {
     567                 :            :         return false;
     568                 :            : }
     569                 :            : 
     570                 :            : static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
     571                 :            : {
     572                 :            :         return NULL;
     573                 :            : }
     574                 :            : 
     575                 :            : static inline bool of_node_name_eq(const struct device_node *np, const char *name)
     576                 :            : {
     577                 :            :         return false;
     578                 :            : }
     579                 :            : 
     580                 :            : static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix)
     581                 :            : {
     582                 :            :         return false;
     583                 :            : }
     584                 :            : 
     585                 :            : static inline const char* of_node_full_name(const struct device_node *np)
     586                 :            : {
     587                 :            :         return "<no-node>";
     588                 :            : }
     589                 :            : 
     590                 :            : static inline struct device_node *of_find_node_by_name(struct device_node *from,
     591                 :            :         const char *name)
     592                 :            : {
     593                 :            :         return NULL;
     594                 :            : }
     595                 :            : 
     596                 :            : static inline struct device_node *of_find_node_by_type(struct device_node *from,
     597                 :            :         const char *type)
     598                 :            : {
     599                 :            :         return NULL;
     600                 :            : }
     601                 :            : 
     602                 :            : static inline struct device_node *of_find_matching_node_and_match(
     603                 :            :         struct device_node *from,
     604                 :            :         const struct of_device_id *matches,
     605                 :            :         const struct of_device_id **match)
     606                 :            : {
     607                 :            :         return NULL;
     608                 :            : }
     609                 :            : 
     610                 :            : static inline struct device_node *of_find_node_by_path(const char *path)
     611                 :            : {
     612                 :            :         return NULL;
     613                 :            : }
     614                 :            : 
     615                 :            : static inline struct device_node *of_find_node_opts_by_path(const char *path,
     616                 :            :         const char **opts)
     617                 :            : {
     618                 :            :         return NULL;
     619                 :            : }
     620                 :            : 
     621                 :            : static inline struct device_node *of_find_node_by_phandle(phandle handle)
     622                 :            : {
     623                 :            :         return NULL;
     624                 :            : }
     625                 :            : 
     626                 :            : static inline struct device_node *of_get_parent(const struct device_node *node)
     627                 :            : {
     628                 :            :         return NULL;
     629                 :            : }
     630                 :            : 
     631                 :            : static inline struct device_node *of_get_next_child(
     632                 :            :         const struct device_node *node, struct device_node *prev)
     633                 :            : {
     634                 :            :         return NULL;
     635                 :            : }
     636                 :            : 
     637                 :            : static inline struct device_node *of_get_next_available_child(
     638                 :            :         const struct device_node *node, struct device_node *prev)
     639                 :            : {
     640                 :            :         return NULL;
     641                 :            : }
     642                 :            : 
     643                 :            : static inline struct device_node *of_find_node_with_property(
     644                 :            :         struct device_node *from, const char *prop_name)
     645                 :            : {
     646                 :            :         return NULL;
     647                 :            : }
     648                 :            : 
     649                 :            : #define of_fwnode_handle(node) NULL
     650                 :            : 
     651                 :            : static inline bool of_have_populated_dt(void)
     652                 :            : {
     653                 :            :         return false;
     654                 :            : }
     655                 :            : 
     656                 :            : static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
     657                 :            :                                         const char *compatible)
     658                 :            : {
     659                 :            :         return NULL;
     660                 :            : }
     661                 :            : 
     662                 :            : static inline struct device_node *of_get_child_by_name(
     663                 :            :                                         const struct device_node *node,
     664                 :            :                                         const char *name)
     665                 :            : {
     666                 :            :         return NULL;
     667                 :            : }
     668                 :            : 
     669                 :            : static inline int of_device_is_compatible(const struct device_node *device,
     670                 :            :                                           const char *name)
     671                 :            : {
     672                 :            :         return 0;
     673                 :            : }
     674                 :            : 
     675                 :            : static inline  int of_device_compatible_match(struct device_node *device,
     676                 :            :                                               const char *const *compat)
     677                 :            : {
     678                 :            :         return 0;
     679                 :            : }
     680                 :            : 
     681                 :            : static inline bool of_device_is_available(const struct device_node *device)
     682                 :            : {
     683                 :            :         return false;
     684                 :            : }
     685                 :            : 
     686                 :            : static inline bool of_device_is_big_endian(const struct device_node *device)
     687                 :            : {
     688                 :            :         return false;
     689                 :            : }
     690                 :            : 
     691                 :            : static inline struct property *of_find_property(const struct device_node *np,
     692                 :            :                                                 const char *name,
     693                 :            :                                                 int *lenp)
     694                 :            : {
     695                 :            :         return NULL;
     696                 :            : }
     697                 :            : 
     698                 :            : static inline struct device_node *of_find_compatible_node(
     699                 :            :                                                 struct device_node *from,
     700                 :            :                                                 const char *type,
     701                 :            :                                                 const char *compat)
     702                 :            : {
     703                 :            :         return NULL;
     704                 :            : }
     705                 :            : 
     706                 :            : static inline int of_property_count_elems_of_size(const struct device_node *np,
     707                 :            :                         const char *propname, int elem_size)
     708                 :            : {
     709                 :            :         return -ENOSYS;
     710                 :            : }
     711                 :            : 
     712                 :            : static inline int of_property_read_u8_array(const struct device_node *np,
     713                 :            :                         const char *propname, u8 *out_values, size_t sz)
     714                 :            : {
     715                 :            :         return -ENOSYS;
     716                 :            : }
     717                 :            : 
     718                 :            : static inline int of_property_read_u16_array(const struct device_node *np,
     719                 :            :                         const char *propname, u16 *out_values, size_t sz)
     720                 :            : {
     721                 :            :         return -ENOSYS;
     722                 :            : }
     723                 :            : 
     724                 :            : static inline int of_property_read_u32_array(const struct device_node *np,
     725                 :            :                                              const char *propname,
     726                 :            :                                              u32 *out_values, size_t sz)
     727                 :            : {
     728                 :            :         return -ENOSYS;
     729                 :            : }
     730                 :            : 
     731                 :            : static inline int of_property_read_u64_array(const struct device_node *np,
     732                 :            :                                              const char *propname,
     733                 :            :                                              u64 *out_values, size_t sz)
     734                 :            : {
     735                 :            :         return -ENOSYS;
     736                 :            : }
     737                 :            : 
     738                 :            : static inline int of_property_read_u32_index(const struct device_node *np,
     739                 :            :                         const char *propname, u32 index, u32 *out_value)
     740                 :            : {
     741                 :            :         return -ENOSYS;
     742                 :            : }
     743                 :            : 
     744                 :            : static inline int of_property_read_u64_index(const struct device_node *np,
     745                 :            :                         const char *propname, u32 index, u64 *out_value)
     746                 :            : {
     747                 :            :         return -ENOSYS;
     748                 :            : }
     749                 :            : 
     750                 :            : static inline const void *of_get_property(const struct device_node *node,
     751                 :            :                                 const char *name,
     752                 :            :                                 int *lenp)
     753                 :            : {
     754                 :            :         return NULL;
     755                 :            : }
     756                 :            : 
     757                 :            : static inline struct device_node *of_get_cpu_node(int cpu,
     758                 :            :                                         unsigned int *thread)
     759                 :            : {
     760                 :            :         return NULL;
     761                 :            : }
     762                 :            : 
     763                 :            : static inline struct device_node *of_get_next_cpu_node(struct device_node *prev)
     764                 :            : {
     765                 :            :         return NULL;
     766                 :            : }
     767                 :            : 
     768                 :            : static inline int of_n_addr_cells(struct device_node *np)
     769                 :            : {
     770                 :            :         return 0;
     771                 :            : 
     772                 :            : }
     773                 :            : static inline int of_n_size_cells(struct device_node *np)
     774                 :            : {
     775                 :            :         return 0;
     776                 :            : }
     777                 :            : 
     778                 :            : static inline int of_property_read_variable_u8_array(const struct device_node *np,
     779                 :            :                                         const char *propname, u8 *out_values,
     780                 :            :                                         size_t sz_min, size_t sz_max)
     781                 :            : {
     782                 :            :         return -ENOSYS;
     783                 :            : }
     784                 :            : 
     785                 :            : static inline int of_property_read_variable_u16_array(const struct device_node *np,
     786                 :            :                                         const char *propname, u16 *out_values,
     787                 :            :                                         size_t sz_min, size_t sz_max)
     788                 :            : {
     789                 :            :         return -ENOSYS;
     790                 :            : }
     791                 :            : 
     792                 :            : static inline int of_property_read_variable_u32_array(const struct device_node *np,
     793                 :            :                                         const char *propname,
     794                 :            :                                         u32 *out_values,
     795                 :            :                                         size_t sz_min,
     796                 :            :                                         size_t sz_max)
     797                 :            : {
     798                 :            :         return -ENOSYS;
     799                 :            : }
     800                 :            : 
     801                 :            : static inline int of_property_read_u64(const struct device_node *np,
     802                 :            :                                        const char *propname, u64 *out_value)
     803                 :            : {
     804                 :            :         return -ENOSYS;
     805                 :            : }
     806                 :            : 
     807                 :            : static inline int of_property_read_variable_u64_array(const struct device_node *np,
     808                 :            :                                         const char *propname,
     809                 :            :                                         u64 *out_values,
     810                 :            :                                         size_t sz_min,
     811                 :            :                                         size_t sz_max)
     812                 :            : {
     813                 :            :         return -ENOSYS;
     814                 :            : }
     815                 :            : 
     816                 :            : static inline int of_property_read_string(const struct device_node *np,
     817                 :            :                                           const char *propname,
     818                 :            :                                           const char **out_string)
     819                 :            : {
     820                 :            :         return -ENOSYS;
     821                 :            : }
     822                 :            : 
     823                 :            : static inline int of_property_match_string(const struct device_node *np,
     824                 :            :                                            const char *propname,
     825                 :            :                                            const char *string)
     826                 :            : {
     827                 :            :         return -ENOSYS;
     828                 :            : }
     829                 :            : 
     830                 :            : static inline int of_property_read_string_helper(const struct device_node *np,
     831                 :            :                                                  const char *propname,
     832                 :            :                                                  const char **out_strs, size_t sz, int index)
     833                 :            : {
     834                 :            :         return -ENOSYS;
     835                 :            : }
     836                 :            : 
     837                 :            : static inline struct device_node *of_parse_phandle(const struct device_node *np,
     838                 :            :                                                    const char *phandle_name,
     839                 :            :                                                    int index)
     840                 :            : {
     841                 :            :         return NULL;
     842                 :            : }
     843                 :            : 
     844                 :            : static inline int of_parse_phandle_with_args(const struct device_node *np,
     845                 :            :                                              const char *list_name,
     846                 :            :                                              const char *cells_name,
     847                 :            :                                              int index,
     848                 :            :                                              struct of_phandle_args *out_args)
     849                 :            : {
     850                 :            :         return -ENOSYS;
     851                 :            : }
     852                 :            : 
     853                 :            : static inline int of_parse_phandle_with_args_map(const struct device_node *np,
     854                 :            :                                                  const char *list_name,
     855                 :            :                                                  const char *stem_name,
     856                 :            :                                                  int index,
     857                 :            :                                                  struct of_phandle_args *out_args)
     858                 :            : {
     859                 :            :         return -ENOSYS;
     860                 :            : }
     861                 :            : 
     862                 :            : static inline int of_parse_phandle_with_fixed_args(const struct device_node *np,
     863                 :            :         const char *list_name, int cells_count, int index,
     864                 :            :         struct of_phandle_args *out_args)
     865                 :            : {
     866                 :            :         return -ENOSYS;
     867                 :            : }
     868                 :            : 
     869                 :            : static inline int of_count_phandle_with_args(struct device_node *np,
     870                 :            :                                              const char *list_name,
     871                 :            :                                              const char *cells_name)
     872                 :            : {
     873                 :            :         return -ENOSYS;
     874                 :            : }
     875                 :            : 
     876                 :            : static inline int of_phandle_iterator_init(struct of_phandle_iterator *it,
     877                 :            :                                            const struct device_node *np,
     878                 :            :                                            const char *list_name,
     879                 :            :                                            const char *cells_name,
     880                 :            :                                            int cell_count)
     881                 :            : {
     882                 :            :         return -ENOSYS;
     883                 :            : }
     884                 :            : 
     885                 :            : static inline int of_phandle_iterator_next(struct of_phandle_iterator *it)
     886                 :            : {
     887                 :            :         return -ENOSYS;
     888                 :            : }
     889                 :            : 
     890                 :            : static inline int of_phandle_iterator_args(struct of_phandle_iterator *it,
     891                 :            :                                            uint32_t *args,
     892                 :            :                                            int size)
     893                 :            : {
     894                 :            :         return 0;
     895                 :            : }
     896                 :            : 
     897                 :            : static inline int of_alias_get_id(struct device_node *np, const char *stem)
     898                 :            : {
     899                 :            :         return -ENOSYS;
     900                 :            : }
     901                 :            : 
     902                 :            : static inline int of_alias_get_highest_id(const char *stem)
     903                 :            : {
     904                 :            :         return -ENOSYS;
     905                 :            : }
     906                 :            : 
     907                 :            : static inline int of_alias_get_alias_list(const struct of_device_id *matches,
     908                 :            :                                           const char *stem, unsigned long *bitmap,
     909                 :            :                                           unsigned int nbits)
     910                 :            : {
     911                 :            :         return -ENOSYS;
     912                 :            : }
     913                 :            : 
     914                 :            : static inline int of_machine_is_compatible(const char *compat)
     915                 :            : {
     916                 :            :         return 0;
     917                 :            : }
     918                 :            : 
     919                 :            : static inline bool of_console_check(const struct device_node *dn, const char *name, int index)
     920                 :            : {
     921                 :            :         return false;
     922                 :            : }
     923                 :            : 
     924                 :            : static inline const __be32 *of_prop_next_u32(struct property *prop,
     925                 :            :                 const __be32 *cur, u32 *pu)
     926                 :            : {
     927                 :            :         return NULL;
     928                 :            : }
     929                 :            : 
     930                 :            : static inline const char *of_prop_next_string(struct property *prop,
     931                 :            :                 const char *cur)
     932                 :            : {
     933                 :            :         return NULL;
     934                 :            : }
     935                 :            : 
     936                 :            : static inline int of_node_check_flag(struct device_node *n, unsigned long flag)
     937                 :            : {
     938                 :            :         return 0;
     939                 :            : }
     940                 :            : 
     941                 :            : static inline int of_node_test_and_set_flag(struct device_node *n,
     942                 :            :                                             unsigned long flag)
     943                 :            : {
     944                 :            :         return 0;
     945                 :            : }
     946                 :            : 
     947                 :            : static inline void of_node_set_flag(struct device_node *n, unsigned long flag)
     948                 :            : {
     949                 :            : }
     950                 :            : 
     951                 :            : static inline void of_node_clear_flag(struct device_node *n, unsigned long flag)
     952                 :            : {
     953                 :            : }
     954                 :            : 
     955                 :            : static inline int of_property_check_flag(struct property *p, unsigned long flag)
     956                 :            : {
     957                 :            :         return 0;
     958                 :            : }
     959                 :            : 
     960                 :            : static inline void of_property_set_flag(struct property *p, unsigned long flag)
     961                 :            : {
     962                 :            : }
     963                 :            : 
     964                 :            : static inline void of_property_clear_flag(struct property *p, unsigned long flag)
     965                 :            : {
     966                 :            : }
     967                 :            : 
     968                 :            : static inline int of_cpu_node_to_id(struct device_node *np)
     969                 :            : {
     970                 :            :         return -ENODEV;
     971                 :            : }
     972                 :            : 
     973                 :            : static inline int of_map_rid(struct device_node *np, u32 rid,
     974                 :            :                              const char *map_name, const char *map_mask_name,
     975                 :            :                              struct device_node **target, u32 *id_out)
     976                 :            : {
     977                 :            :         return -EINVAL;
     978                 :            : }
     979                 :            : 
     980                 :            : #define of_match_ptr(_ptr)      NULL
     981                 :            : #define of_match_node(_matches, _node)  NULL
     982                 :            : #endif /* CONFIG_OF */
     983                 :            : 
     984                 :            : /* Default string compare functions, Allow arch asm/prom.h to override */
     985                 :            : #if !defined(of_compat_cmp)
     986                 :            : #define of_compat_cmp(s1, s2, l)        strcasecmp((s1), (s2))
     987                 :            : #define of_prop_cmp(s1, s2)             strcmp((s1), (s2))
     988                 :            : #define of_node_cmp(s1, s2)             strcasecmp((s1), (s2))
     989                 :            : #endif
     990                 :            : 
     991                 :          0 : static inline int of_prop_val_eq(struct property *p1, struct property *p2)
     992                 :            : {
     993                 :          0 :         return p1->length == p2->length &&
     994                 :          0 :                !memcmp(p1->value, p2->value, (size_t)p1->length);
     995                 :            : }
     996                 :            : 
     997                 :            : #if defined(CONFIG_OF) && defined(CONFIG_NUMA)
     998                 :            : extern int of_node_to_nid(struct device_node *np);
     999                 :            : #else
    1000                 :            : static inline int of_node_to_nid(struct device_node *device)
    1001                 :            : {
    1002                 :            :         return NUMA_NO_NODE;
    1003                 :            : }
    1004                 :            : #endif
    1005                 :            : 
    1006                 :            : #ifdef CONFIG_OF_NUMA
    1007                 :            : extern int of_numa_init(void);
    1008                 :            : #else
    1009                 :            : static inline int of_numa_init(void)
    1010                 :            : {
    1011                 :            :         return -ENOSYS;
    1012                 :            : }
    1013                 :            : #endif
    1014                 :            : 
    1015                 :            : static inline struct device_node *of_find_matching_node(
    1016                 :            :         struct device_node *from,
    1017                 :            :         const struct of_device_id *matches)
    1018                 :            : {
    1019                 :          3 :         return of_find_matching_node_and_match(from, matches, NULL);
    1020                 :            : }
    1021                 :            : 
    1022                 :            : static inline const char *of_node_get_device_type(const struct device_node *np)
    1023                 :            : {
    1024                 :          3 :         return of_get_property(np, "device_type", NULL);
    1025                 :            : }
    1026                 :            : 
    1027                 :            : static inline bool of_node_is_type(const struct device_node *np, const char *type)
    1028                 :            : {
    1029                 :            :         const char *match = of_node_get_device_type(np);
    1030                 :            : 
    1031                 :            :         return np && match && type && !strcmp(match, type);
    1032                 :            : }
    1033                 :            : 
    1034                 :            : /**
    1035                 :            :  * of_property_count_u8_elems - Count the number of u8 elements in a property
    1036                 :            :  *
    1037                 :            :  * @np:         device node from which the property value is to be read.
    1038                 :            :  * @propname:   name of the property to be searched.
    1039                 :            :  *
    1040                 :            :  * Search for a property in a device node and count the number of u8 elements
    1041                 :            :  * in it. Returns number of elements on sucess, -EINVAL if the property does
    1042                 :            :  * not exist or its length does not match a multiple of u8 and -ENODATA if the
    1043                 :            :  * property does not have a value.
    1044                 :            :  */
    1045                 :            : static inline int of_property_count_u8_elems(const struct device_node *np,
    1046                 :            :                                 const char *propname)
    1047                 :            : {
    1048                 :            :         return of_property_count_elems_of_size(np, propname, sizeof(u8));
    1049                 :            : }
    1050                 :            : 
    1051                 :            : /**
    1052                 :            :  * of_property_count_u16_elems - Count the number of u16 elements in a property
    1053                 :            :  *
    1054                 :            :  * @np:         device node from which the property value is to be read.
    1055                 :            :  * @propname:   name of the property to be searched.
    1056                 :            :  *
    1057                 :            :  * Search for a property in a device node and count the number of u16 elements
    1058                 :            :  * in it. Returns number of elements on sucess, -EINVAL if the property does
    1059                 :            :  * not exist or its length does not match a multiple of u16 and -ENODATA if the
    1060                 :            :  * property does not have a value.
    1061                 :            :  */
    1062                 :            : static inline int of_property_count_u16_elems(const struct device_node *np,
    1063                 :            :                                 const char *propname)
    1064                 :            : {
    1065                 :            :         return of_property_count_elems_of_size(np, propname, sizeof(u16));
    1066                 :            : }
    1067                 :            : 
    1068                 :            : /**
    1069                 :            :  * of_property_count_u32_elems - Count the number of u32 elements in a property
    1070                 :            :  *
    1071                 :            :  * @np:         device node from which the property value is to be read.
    1072                 :            :  * @propname:   name of the property to be searched.
    1073                 :            :  *
    1074                 :            :  * Search for a property in a device node and count the number of u32 elements
    1075                 :            :  * in it. Returns number of elements on sucess, -EINVAL if the property does
    1076                 :            :  * not exist or its length does not match a multiple of u32 and -ENODATA if the
    1077                 :            :  * property does not have a value.
    1078                 :            :  */
    1079                 :            : static inline int of_property_count_u32_elems(const struct device_node *np,
    1080                 :            :                                 const char *propname)
    1081                 :            : {
    1082                 :          3 :         return of_property_count_elems_of_size(np, propname, sizeof(u32));
    1083                 :            : }
    1084                 :            : 
    1085                 :            : /**
    1086                 :            :  * of_property_count_u64_elems - Count the number of u64 elements in a property
    1087                 :            :  *
    1088                 :            :  * @np:         device node from which the property value is to be read.
    1089                 :            :  * @propname:   name of the property to be searched.
    1090                 :            :  *
    1091                 :            :  * Search for a property in a device node and count the number of u64 elements
    1092                 :            :  * in it. Returns number of elements on sucess, -EINVAL if the property does
    1093                 :            :  * not exist or its length does not match a multiple of u64 and -ENODATA if the
    1094                 :            :  * property does not have a value.
    1095                 :            :  */
    1096                 :            : static inline int of_property_count_u64_elems(const struct device_node *np,
    1097                 :            :                                 const char *propname)
    1098                 :            : {
    1099                 :            :         return of_property_count_elems_of_size(np, propname, sizeof(u64));
    1100                 :            : }
    1101                 :            : 
    1102                 :            : /**
    1103                 :            :  * of_property_read_string_array() - Read an array of strings from a multiple
    1104                 :            :  * strings property.
    1105                 :            :  * @np:         device node from which the property value is to be read.
    1106                 :            :  * @propname:   name of the property to be searched.
    1107                 :            :  * @out_strs:   output array of string pointers.
    1108                 :            :  * @sz:         number of array elements to read.
    1109                 :            :  *
    1110                 :            :  * Search for a property in a device tree node and retrieve a list of
    1111                 :            :  * terminated string values (pointer to data, not a copy) in that property.
    1112                 :            :  *
    1113                 :            :  * If @out_strs is NULL, the number of strings in the property is returned.
    1114                 :            :  */
    1115                 :            : static inline int of_property_read_string_array(const struct device_node *np,
    1116                 :            :                                                 const char *propname, const char **out_strs,
    1117                 :            :                                                 size_t sz)
    1118                 :            : {
    1119                 :          3 :         return of_property_read_string_helper(np, propname, out_strs, sz, 0);
    1120                 :            : }
    1121                 :            : 
    1122                 :            : /**
    1123                 :            :  * of_property_count_strings() - Find and return the number of strings from a
    1124                 :            :  * multiple strings property.
    1125                 :            :  * @np:         device node from which the property value is to be read.
    1126                 :            :  * @propname:   name of the property to be searched.
    1127                 :            :  *
    1128                 :            :  * Search for a property in a device tree node and retrieve the number of null
    1129                 :            :  * terminated string contain in it. Returns the number of strings on
    1130                 :            :  * success, -EINVAL if the property does not exist, -ENODATA if property
    1131                 :            :  * does not have a value, and -EILSEQ if the string is not null-terminated
    1132                 :            :  * within the length of the property data.
    1133                 :            :  */
    1134                 :            : static inline int of_property_count_strings(const struct device_node *np,
    1135                 :            :                                             const char *propname)
    1136                 :            : {
    1137                 :          3 :         return of_property_read_string_helper(np, propname, NULL, 0, 0);
    1138                 :            : }
    1139                 :            : 
    1140                 :            : /**
    1141                 :            :  * of_property_read_string_index() - Find and read a string from a multiple
    1142                 :            :  * strings property.
    1143                 :            :  * @np:         device node from which the property value is to be read.
    1144                 :            :  * @propname:   name of the property to be searched.
    1145                 :            :  * @index:      index of the string in the list of strings
    1146                 :            :  * @out_string: pointer to null terminated return string, modified only if
    1147                 :            :  *              return value is 0.
    1148                 :            :  *
    1149                 :            :  * Search for a property in a device tree node and retrieve a null
    1150                 :            :  * terminated string value (pointer to data, not a copy) in the list of strings
    1151                 :            :  * contained in that property.
    1152                 :            :  * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
    1153                 :            :  * property does not have a value, and -EILSEQ if the string is not
    1154                 :            :  * null-terminated within the length of the property data.
    1155                 :            :  *
    1156                 :            :  * The out_string pointer is modified only if a valid string can be decoded.
    1157                 :            :  */
    1158                 :            : static inline int of_property_read_string_index(const struct device_node *np,
    1159                 :            :                                                 const char *propname,
    1160                 :            :                                                 int index, const char **output)
    1161                 :            : {
    1162                 :          3 :         int rc = of_property_read_string_helper(np, propname, output, 1, index);
    1163                 :            :         return rc < 0 ? rc : 0;
    1164                 :            : }
    1165                 :            : 
    1166                 :            : /**
    1167                 :            :  * of_property_read_bool - Find a property
    1168                 :            :  * @np:         device node from which the property value is to be read.
    1169                 :            :  * @propname:   name of the property to be searched.
    1170                 :            :  *
    1171                 :            :  * Search for a property in a device node.
    1172                 :            :  * Returns true if the property exists false otherwise.
    1173                 :            :  */
    1174                 :            : static inline bool of_property_read_bool(const struct device_node *np,
    1175                 :            :                                          const char *propname)
    1176                 :            : {
    1177                 :          3 :         struct property *prop = of_find_property(np, propname, NULL);
    1178                 :            : 
    1179                 :          3 :         return prop ? true : false;
    1180                 :            : }
    1181                 :            : 
    1182                 :            : static inline int of_property_read_u8(const struct device_node *np,
    1183                 :            :                                        const char *propname,
    1184                 :            :                                        u8 *out_value)
    1185                 :            : {
    1186                 :            :         return of_property_read_u8_array(np, propname, out_value, 1);
    1187                 :            : }
    1188                 :            : 
    1189                 :            : static inline int of_property_read_u16(const struct device_node *np,
    1190                 :            :                                        const char *propname,
    1191                 :            :                                        u16 *out_value)
    1192                 :            : {
    1193                 :            :         return of_property_read_u16_array(np, propname, out_value, 1);
    1194                 :            : }
    1195                 :            : 
    1196                 :            : static inline int of_property_read_u32(const struct device_node *np,
    1197                 :            :                                        const char *propname,
    1198                 :            :                                        u32 *out_value)
    1199                 :            : {
    1200                 :            :         return of_property_read_u32_array(np, propname, out_value, 1);
    1201                 :            : }
    1202                 :            : 
    1203                 :            : static inline int of_property_read_s32(const struct device_node *np,
    1204                 :            :                                        const char *propname,
    1205                 :            :                                        s32 *out_value)
    1206                 :            : {
    1207                 :            :         return of_property_read_u32(np, propname, (u32*) out_value);
    1208                 :            : }
    1209                 :            : 
    1210                 :            : #define of_for_each_phandle(it, err, np, ln, cn, cc)                    \
    1211                 :            :         for (of_phandle_iterator_init((it), (np), (ln), (cn), (cc)),    \
    1212                 :            :              err = of_phandle_iterator_next(it);                        \
    1213                 :            :              err == 0;                                                  \
    1214                 :            :              err = of_phandle_iterator_next(it))
    1215                 :            : 
    1216                 :            : #define of_property_for_each_u32(np, propname, prop, p, u)      \
    1217                 :            :         for (prop = of_find_property(np, propname, NULL),       \
    1218                 :            :                 p = of_prop_next_u32(prop, NULL, &u);               \
    1219                 :            :                 p;                                              \
    1220                 :            :                 p = of_prop_next_u32(prop, p, &u))
    1221                 :            : 
    1222                 :            : #define of_property_for_each_string(np, propname, prop, s)      \
    1223                 :            :         for (prop = of_find_property(np, propname, NULL),       \
    1224                 :            :                 s = of_prop_next_string(prop, NULL);            \
    1225                 :            :                 s;                                              \
    1226                 :            :                 s = of_prop_next_string(prop, s))
    1227                 :            : 
    1228                 :            : #define for_each_node_by_name(dn, name) \
    1229                 :            :         for (dn = of_find_node_by_name(NULL, name); dn; \
    1230                 :            :              dn = of_find_node_by_name(dn, name))
    1231                 :            : #define for_each_node_by_type(dn, type) \
    1232                 :            :         for (dn = of_find_node_by_type(NULL, type); dn; \
    1233                 :            :              dn = of_find_node_by_type(dn, type))
    1234                 :            : #define for_each_compatible_node(dn, type, compatible) \
    1235                 :            :         for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
    1236                 :            :              dn = of_find_compatible_node(dn, type, compatible))
    1237                 :            : #define for_each_matching_node(dn, matches) \
    1238                 :            :         for (dn = of_find_matching_node(NULL, matches); dn; \
    1239                 :            :              dn = of_find_matching_node(dn, matches))
    1240                 :            : #define for_each_matching_node_and_match(dn, matches, match) \
    1241                 :            :         for (dn = of_find_matching_node_and_match(NULL, matches, match); \
    1242                 :            :              dn; dn = of_find_matching_node_and_match(dn, matches, match))
    1243                 :            : 
    1244                 :            : #define for_each_child_of_node(parent, child) \
    1245                 :            :         for (child = of_get_next_child(parent, NULL); child != NULL; \
    1246                 :            :              child = of_get_next_child(parent, child))
    1247                 :            : #define for_each_available_child_of_node(parent, child) \
    1248                 :            :         for (child = of_get_next_available_child(parent, NULL); child != NULL; \
    1249                 :            :              child = of_get_next_available_child(parent, child))
    1250                 :            : 
    1251                 :            : #define for_each_of_cpu_node(cpu) \
    1252                 :            :         for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \
    1253                 :            :              cpu = of_get_next_cpu_node(cpu))
    1254                 :            : 
    1255                 :            : #define for_each_node_with_property(dn, prop_name) \
    1256                 :            :         for (dn = of_find_node_with_property(NULL, prop_name); dn; \
    1257                 :            :              dn = of_find_node_with_property(dn, prop_name))
    1258                 :            : 
    1259                 :          0 : static inline int of_get_child_count(const struct device_node *np)
    1260                 :            : {
    1261                 :            :         struct device_node *child;
    1262                 :            :         int num = 0;
    1263                 :            : 
    1264                 :          0 :         for_each_child_of_node(np, child)
    1265                 :          0 :                 num++;
    1266                 :            : 
    1267                 :          0 :         return num;
    1268                 :            : }
    1269                 :            : 
    1270                 :            : static inline int of_get_available_child_count(const struct device_node *np)
    1271                 :            : {
    1272                 :            :         struct device_node *child;
    1273                 :            :         int num = 0;
    1274                 :            : 
    1275                 :            :         for_each_available_child_of_node(np, child)
    1276                 :            :                 num++;
    1277                 :            : 
    1278                 :            :         return num;
    1279                 :            : }
    1280                 :            : 
    1281                 :            : #if defined(CONFIG_OF) && !defined(MODULE)
    1282                 :            : #define _OF_DECLARE(table, name, compat, fn, fn_type)                   \
    1283                 :            :         static const struct of_device_id __of_table_##name              \
    1284                 :            :                 __used __section(__##table##_of_table)                  \
    1285                 :            :                  = { .compatible = compat,                              \
    1286                 :            :                      .data = (fn == (fn_type)NULL) ? fn : fn  }
    1287                 :            : #else
    1288                 :            : #define _OF_DECLARE(table, name, compat, fn, fn_type)                   \
    1289                 :            :         static const struct of_device_id __of_table_##name              \
    1290                 :            :                 __attribute__((unused))                                 \
    1291                 :            :                  = { .compatible = compat,                              \
    1292                 :            :                      .data = (fn == (fn_type)NULL) ? fn : fn }
    1293                 :            : #endif
    1294                 :            : 
    1295                 :            : typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
    1296                 :            : typedef int (*of_init_fn_1_ret)(struct device_node *);
    1297                 :            : typedef void (*of_init_fn_1)(struct device_node *);
    1298                 :            : 
    1299                 :            : #define OF_DECLARE_1(table, name, compat, fn) \
    1300                 :            :                 _OF_DECLARE(table, name, compat, fn, of_init_fn_1)
    1301                 :            : #define OF_DECLARE_1_RET(table, name, compat, fn) \
    1302                 :            :                 _OF_DECLARE(table, name, compat, fn, of_init_fn_1_ret)
    1303                 :            : #define OF_DECLARE_2(table, name, compat, fn) \
    1304                 :            :                 _OF_DECLARE(table, name, compat, fn, of_init_fn_2)
    1305                 :            : 
    1306                 :            : /**
    1307                 :            :  * struct of_changeset_entry    - Holds a changeset entry
    1308                 :            :  *
    1309                 :            :  * @node:       list_head for the log list
    1310                 :            :  * @action:     notifier action
    1311                 :            :  * @np:         pointer to the device node affected
    1312                 :            :  * @prop:       pointer to the property affected
    1313                 :            :  * @old_prop:   hold a pointer to the original property
    1314                 :            :  *
    1315                 :            :  * Every modification of the device tree during a changeset
    1316                 :            :  * is held in a list of of_changeset_entry structures.
    1317                 :            :  * That way we can recover from a partial application, or we can
    1318                 :            :  * revert the changeset
    1319                 :            :  */
    1320                 :            : struct of_changeset_entry {
    1321                 :            :         struct list_head node;
    1322                 :            :         unsigned long action;
    1323                 :            :         struct device_node *np;
    1324                 :            :         struct property *prop;
    1325                 :            :         struct property *old_prop;
    1326                 :            : };
    1327                 :            : 
    1328                 :            : /**
    1329                 :            :  * struct of_changeset - changeset tracker structure
    1330                 :            :  *
    1331                 :            :  * @entries:    list_head for the changeset entries
    1332                 :            :  *
    1333                 :            :  * changesets are a convenient way to apply bulk changes to the
    1334                 :            :  * live tree. In case of an error, changes are rolled-back.
    1335                 :            :  * changesets live on after initial application, and if not
    1336                 :            :  * destroyed after use, they can be reverted in one single call.
    1337                 :            :  */
    1338                 :            : struct of_changeset {
    1339                 :            :         struct list_head entries;
    1340                 :            : };
    1341                 :            : 
    1342                 :            : enum of_reconfig_change {
    1343                 :            :         OF_RECONFIG_NO_CHANGE = 0,
    1344                 :            :         OF_RECONFIG_CHANGE_ADD,
    1345                 :            :         OF_RECONFIG_CHANGE_REMOVE,
    1346                 :            : };
    1347                 :            : 
    1348                 :            : #ifdef CONFIG_OF_DYNAMIC
    1349                 :            : extern int of_reconfig_notifier_register(struct notifier_block *);
    1350                 :            : extern int of_reconfig_notifier_unregister(struct notifier_block *);
    1351                 :            : extern int of_reconfig_notify(unsigned long, struct of_reconfig_data *rd);
    1352                 :            : extern int of_reconfig_get_state_change(unsigned long action,
    1353                 :            :                                         struct of_reconfig_data *arg);
    1354                 :            : 
    1355                 :            : extern void of_changeset_init(struct of_changeset *ocs);
    1356                 :            : extern void of_changeset_destroy(struct of_changeset *ocs);
    1357                 :            : extern int of_changeset_apply(struct of_changeset *ocs);
    1358                 :            : extern int of_changeset_revert(struct of_changeset *ocs);
    1359                 :            : extern int of_changeset_action(struct of_changeset *ocs,
    1360                 :            :                 unsigned long action, struct device_node *np,
    1361                 :            :                 struct property *prop);
    1362                 :            : 
    1363                 :            : static inline int of_changeset_attach_node(struct of_changeset *ocs,
    1364                 :            :                 struct device_node *np)
    1365                 :            : {
    1366                 :          0 :         return of_changeset_action(ocs, OF_RECONFIG_ATTACH_NODE, np, NULL);
    1367                 :            : }
    1368                 :            : 
    1369                 :            : static inline int of_changeset_detach_node(struct of_changeset *ocs,
    1370                 :            :                 struct device_node *np)
    1371                 :            : {
    1372                 :            :         return of_changeset_action(ocs, OF_RECONFIG_DETACH_NODE, np, NULL);
    1373                 :            : }
    1374                 :            : 
    1375                 :            : static inline int of_changeset_add_property(struct of_changeset *ocs,
    1376                 :            :                 struct device_node *np, struct property *prop)
    1377                 :            : {
    1378                 :          0 :         return of_changeset_action(ocs, OF_RECONFIG_ADD_PROPERTY, np, prop);
    1379                 :            : }
    1380                 :            : 
    1381                 :            : static inline int of_changeset_remove_property(struct of_changeset *ocs,
    1382                 :            :                 struct device_node *np, struct property *prop)
    1383                 :            : {
    1384                 :            :         return of_changeset_action(ocs, OF_RECONFIG_REMOVE_PROPERTY, np, prop);
    1385                 :            : }
    1386                 :            : 
    1387                 :            : static inline int of_changeset_update_property(struct of_changeset *ocs,
    1388                 :            :                 struct device_node *np, struct property *prop)
    1389                 :            : {
    1390                 :          0 :         return of_changeset_action(ocs, OF_RECONFIG_UPDATE_PROPERTY, np, prop);
    1391                 :            : }
    1392                 :            : #else /* CONFIG_OF_DYNAMIC */
    1393                 :            : static inline int of_reconfig_notifier_register(struct notifier_block *nb)
    1394                 :            : {
    1395                 :            :         return -EINVAL;
    1396                 :            : }
    1397                 :            : static inline int of_reconfig_notifier_unregister(struct notifier_block *nb)
    1398                 :            : {
    1399                 :            :         return -EINVAL;
    1400                 :            : }
    1401                 :            : static inline int of_reconfig_notify(unsigned long action,
    1402                 :            :                                      struct of_reconfig_data *arg)
    1403                 :            : {
    1404                 :            :         return -EINVAL;
    1405                 :            : }
    1406                 :            : static inline int of_reconfig_get_state_change(unsigned long action,
    1407                 :            :                                                 struct of_reconfig_data *arg)
    1408                 :            : {
    1409                 :            :         return -EINVAL;
    1410                 :            : }
    1411                 :            : #endif /* CONFIG_OF_DYNAMIC */
    1412                 :            : 
    1413                 :            : /**
    1414                 :            :  * of_device_is_system_power_controller - Tells if system-power-controller is found for device_node
    1415                 :            :  * @np: Pointer to the given device_node
    1416                 :            :  *
    1417                 :            :  * return true if present false otherwise
    1418                 :            :  */
    1419                 :            : static inline bool of_device_is_system_power_controller(const struct device_node *np)
    1420                 :            : {
    1421                 :            :         return of_property_read_bool(np, "system-power-controller");
    1422                 :            : }
    1423                 :            : 
    1424                 :            : /**
    1425                 :            :  * Overlay support
    1426                 :            :  */
    1427                 :            : 
    1428                 :            : enum of_overlay_notify_action {
    1429                 :            :         OF_OVERLAY_PRE_APPLY = 0,
    1430                 :            :         OF_OVERLAY_POST_APPLY,
    1431                 :            :         OF_OVERLAY_PRE_REMOVE,
    1432                 :            :         OF_OVERLAY_POST_REMOVE,
    1433                 :            : };
    1434                 :            : 
    1435                 :            : struct of_overlay_notify_data {
    1436                 :            :         struct device_node *overlay;
    1437                 :            :         struct device_node *target;
    1438                 :            : };
    1439                 :            : 
    1440                 :            : #ifdef CONFIG_OF_OVERLAY
    1441                 :            : 
    1442                 :            : int of_overlay_fdt_apply(const void *overlay_fdt, u32 overlay_fdt_size,
    1443                 :            :                          int *ovcs_id);
    1444                 :            : int of_overlay_remove(int *ovcs_id);
    1445                 :            : int of_overlay_remove_all(void);
    1446                 :            : 
    1447                 :            : int of_overlay_notifier_register(struct notifier_block *nb);
    1448                 :            : int of_overlay_notifier_unregister(struct notifier_block *nb);
    1449                 :            : 
    1450                 :            : #else
    1451                 :            : 
    1452                 :            : static inline int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size,
    1453                 :            :                                        int *ovcs_id)
    1454                 :            : {
    1455                 :            :         return -ENOTSUPP;
    1456                 :            : }
    1457                 :            : 
    1458                 :            : static inline int of_overlay_remove(int *ovcs_id)
    1459                 :            : {
    1460                 :            :         return -ENOTSUPP;
    1461                 :            : }
    1462                 :            : 
    1463                 :            : static inline int of_overlay_remove_all(void)
    1464                 :            : {
    1465                 :            :         return -ENOTSUPP;
    1466                 :            : }
    1467                 :            : 
    1468                 :            : static inline int of_overlay_notifier_register(struct notifier_block *nb)
    1469                 :            : {
    1470                 :            :         return 0;
    1471                 :            : }
    1472                 :            : 
    1473                 :            : static inline int of_overlay_notifier_unregister(struct notifier_block *nb)
    1474                 :            : {
    1475                 :            :         return 0;
    1476                 :            : }
    1477                 :            : 
    1478                 :            : #endif
    1479                 :            : 
    1480                 :            : #endif /* _LINUX_OF_H */
    

Generated by: LCOV version 1.14