drivers/base/property.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * property.c - Unified device property interface.
   4  *
   5  * Copyright (C) 2014, Intel Corporation
   6  * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   7  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   8  */
   9
  10 #include <linux/acpi.h>
  11 #include <linux/export.h>
  12 #include <linux/kernel.h>
  13 #include <linux/of.h>
  14 #include <linux/of_address.h>
  15 #include <linux/of_graph.h>
  16 #include <linux/of_irq.h>
  17 #include <linux/property.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/phy.h>
  20
  21 struct property_set {
  22         struct device *dev;
  23         struct fwnode_handle fwnode;
  24         const struct property_entry *properties;
  25 };
  26
  27 static const struct fwnode_operations pset_fwnode_ops;
  28
  29 static inline bool is_pset_node(const struct fwnode_handle *fwnode)
  30 {
  31         return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &pset_fwnode_ops;
  32 }
  33
  34 #define to_pset_node(__fwnode)                                          \
  35         ({                                                              \
  36                 typeof(__fwnode) __to_pset_node_fwnode = __fwnode;      \
  37                                                                         \
  38                 is_pset_node(__to_pset_node_fwnode) ?                   \
  39                         container_of(__to_pset_node_fwnode,             \
  40                                      struct property_set, fwnode) :     \
  41                         NULL;                                           \
  42         })
  43
  44 static const struct property_entry *
  45 pset_prop_get(const struct property_set *pset, const char *name)
  46 {
  47         const struct property_entry *prop;
  48
  49         if (!pset || !pset->properties)
  50                 return NULL;
  51
  52         for (prop = pset->properties; prop->name; prop++)
  53                 if (!strcmp(name, prop->name))
  54                         return prop;
  55
  56         return NULL;
  57 }
  58
  59 static const void *pset_prop_find(const struct property_set *pset,
  60                                   const char *propname, size_t length)
  61 {
  62         const struct property_entry *prop;
  63         const void *pointer;
  64
  65         prop = pset_prop_get(pset, propname);
  66         if (!prop)
  67                 return ERR_PTR(-EINVAL);
  68         if (prop->is_array)
  69                 pointer = prop->pointer.raw_data;
  70         else
  71                 pointer = &prop->value.raw_data;
  72         if (!pointer)
  73                 return ERR_PTR(-ENODATA);
  74         if (length > prop->length)
  75                 return ERR_PTR(-EOVERFLOW);
  76         return pointer;
  77 }
  78
  79 static int pset_prop_read_u8_array(const struct property_set *pset,
  80                                    const char *propname,
  81                                    u8 *values, size_t nval)
  82 {
  83         const void *pointer;
  84         size_t length = nval * sizeof(*values);
  85
  86         pointer = pset_prop_find(pset, propname, length);
  87         if (IS_ERR(pointer))
  88                 return PTR_ERR(pointer);
  89
  90         memcpy(values, pointer, length);
  91         return 0;
  92 }
  93
  94 static int pset_prop_read_u16_array(const struct property_set *pset,
  95                                     const char *propname,
  96                                     u16 *values, size_t nval)
  97 {
  98         const void *pointer;
  99         size_t length = nval * sizeof(*values);
 100
 101         pointer = pset_prop_find(pset, propname, length);
 102         if (IS_ERR(pointer))
 103                 return PTR_ERR(pointer);
 104
 105         memcpy(values, pointer, length);
 106         return 0;
 107 }
 108
 109 static int pset_prop_read_u32_array(const struct property_set *pset,
 110                                     const char *propname,
 111                                     u32 *values, size_t nval)
 112 {
 113         const void *pointer;
 114         size_t length = nval * sizeof(*values);
 115
 116         pointer = pset_prop_find(pset, propname, length);
 117         if (IS_ERR(pointer))
 118                 return PTR_ERR(pointer);
 119
 120         memcpy(values, pointer, length);
 121         return 0;
 122 }
 123
 124 static int pset_prop_read_u64_array(const struct property_set *pset,
 125                                     const char *propname,
 126                                     u64 *values, size_t nval)
 127 {
 128         const void *pointer;
 129         size_t length = nval * sizeof(*values);
 130
 131         pointer = pset_prop_find(pset, propname, length);
 132         if (IS_ERR(pointer))
 133                 return PTR_ERR(pointer);
 134
 135         memcpy(values, pointer, length);
 136         return 0;
 137 }
 138
 139 static int pset_prop_count_elems_of_size(const struct property_set *pset,
 140                                          const char *propname, size_t length)
 141 {
 142         const struct property_entry *prop;
 143
 144         prop = pset_prop_get(pset, propname);
 145         if (!prop)
 146                 return -EINVAL;
 147
 148         return prop->length / length;
 149 }
 150
 151 static int pset_prop_read_string_array(const struct property_set *pset,
 152                                        const char *propname,
 153                                        const char **strings, size_t nval)
 154 {
 155         const struct property_entry *prop;
 156         const void *pointer;
 157         size_t array_len, length;
 158
 159         /* Find out the array length. */
 160         prop = pset_prop_get(pset, propname);
 161         if (!prop)
 162                 return -EINVAL;
 163
 164         if (!prop->is_array)
 165                 /* The array length for a non-array string property is 1. */
 166                 array_len = 1;
 167         else
 168                 /* Find the length of an array. */
 169                 array_len = pset_prop_count_elems_of_size(pset, propname,
 170                                                           sizeof(const char *));
 171
 172         /* Return how many there are if strings is NULL. */
 173         if (!strings)
 174                 return array_len;
 175
 176         array_len = min(nval, array_len);
 177         length = array_len * sizeof(*strings);
 178
 179         pointer = pset_prop_find(pset, propname, length);
 180         if (IS_ERR(pointer))
 181                 return PTR_ERR(pointer);
 182
 183         memcpy(strings, pointer, length);
 184
 185         return array_len;
 186 }
 187
 188 struct fwnode_handle *dev_fwnode(struct device *dev)
 189 {
 190         return IS_ENABLED(CONFIG_OF) && dev->of_node ?
 191                 &dev->of_node->fwnode : dev->fwnode;
 192 }
 193 EXPORT_SYMBOL_GPL(dev_fwnode);
 194
 195 static bool pset_fwnode_property_present(const struct fwnode_handle *fwnode,
 196                                          const char *propname)
 197 {
 198         return !!pset_prop_get(to_pset_node(fwnode), propname);
 199 }
 200
 201 static int pset_fwnode_read_int_array(const struct fwnode_handle *fwnode,
 202                                       const char *propname,
 203                                       unsigned int elem_size, void *val,
 204                                       size_t nval)
 205 {
 206         const struct property_set *node = to_pset_node(fwnode);
 207
 208         if (!val)
 209                 return pset_prop_count_elems_of_size(node, propname, elem_size);
 210
 211         switch (elem_size) {
 212         case sizeof(u8):
 213                 return pset_prop_read_u8_array(node, propname, val, nval);
 214         case sizeof(u16):
 215                 return pset_prop_read_u16_array(node, propname, val, nval);
 216         case sizeof(u32):
 217                 return pset_prop_read_u32_array(node, propname, val, nval);
 218         case sizeof(u64):
 219                 return pset_prop_read_u64_array(node, propname, val, nval);
 220         }
 221
 222         return -ENXIO;
 223 }
 224
 225 static int
 226 pset_fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 227                                        const char *propname,
 228                                        const char **val, size_t nval)
 229 {
 230         return pset_prop_read_string_array(to_pset_node(fwnode), propname,
 231                                            val, nval);
 232 }
 233
 234 static const struct fwnode_operations pset_fwnode_ops = {
 235         .property_present = pset_fwnode_property_present,
 236         .property_read_int_array = pset_fwnode_read_int_array,
 237         .property_read_string_array = pset_fwnode_property_read_string_array,
 238 };
 239
 240 /**
 241  * device_property_present - check if a property of a device is present
 242  * @dev: Device whose property is being checked
 243  * @propname: Name of the property
 244  *
 245  * Check if property @propname is present in the device firmware description.
 246  */
 247 bool device_property_present(struct device *dev, const char *propname)
 248 {
 249         return fwnode_property_present(dev_fwnode(dev), propname);
 250 }
 251 EXPORT_SYMBOL_GPL(device_property_present);
 252
 253 /**
 254  * fwnode_property_present - check if a property of a firmware node is present
 255  * @fwnode: Firmware node whose property to check
 256  * @propname: Name of the property
 257  */
 258 bool fwnode_property_present(const struct fwnode_handle *fwnode,
 259                              const char *propname)
 260 {
 261         bool ret;
 262
 263         ret = fwnode_call_bool_op(fwnode, property_present, propname);
 264         if (ret == false && !IS_ERR_OR_NULL(fwnode) &&
 265             !IS_ERR_OR_NULL(fwnode->secondary))
 266                 ret = fwnode_call_bool_op(fwnode->secondary, property_present,
 267                                          propname);
 268         return ret;
 269 }
 270 EXPORT_SYMBOL_GPL(fwnode_property_present);
 271
 272 /**
 273  * device_property_read_u8_array - return a u8 array property of a device
 274  * @dev: Device to get the property of
 275  * @propname: Name of the property
 276  * @val: The values are stored here or %NULL to return the number of values
 277  * @nval: Size of the @val array
 278  *
 279  * Function reads an array of u8 properties with @propname from the device
 280  * firmware description and stores them to @val if found.
 281  *
 282  * Return: number of values if @val was %NULL,
 283  *         %0 if the property was found (success),
 284  *         %-EINVAL if given arguments are not valid,
 285  *         %-ENODATA if the property does not have a value,
 286  *         %-EPROTO if the property is not an array of numbers,
 287  *         %-EOVERFLOW if the size of the property is not as expected.
 288  *         %-ENXIO if no suitable firmware interface is present.
 289  */
 290 int device_property_read_u8_array(struct device *dev, const char *propname,
 291                                   u8 *val, size_t nval)
 292 {
 293         return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval);
 294 }
 295 EXPORT_SYMBOL_GPL(device_property_read_u8_array);
 296
 297 /**
 298  * device_property_read_u16_array - return a u16 array property of a device
 299  * @dev: Device to get the property of
 300  * @propname: Name of the property
 301  * @val: The values are stored here or %NULL to return the number of values
 302  * @nval: Size of the @val array
 303  *
 304  * Function reads an array of u16 properties with @propname from the device
 305  * firmware description and stores them to @val if found.
 306  *
 307  * Return: number of values if @val was %NULL,
 308  *         %0 if the property was found (success),
 309  *         %-EINVAL if given arguments are not valid,
 310  *         %-ENODATA if the property does not have a value,
 311  *         %-EPROTO if the property is not an array of numbers,
 312  *         %-EOVERFLOW if the size of the property is not as expected.
 313  *         %-ENXIO if no suitable firmware interface is present.
 314  */
 315 int device_property_read_u16_array(struct device *dev, const char *propname,
 316                                    u16 *val, size_t nval)
 317 {
 318         return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval);
 319 }
 320 EXPORT_SYMBOL_GPL(device_property_read_u16_array);
 321
 322 /**
 323  * device_property_read_u32_array - return a u32 array property of a device
 324  * @dev: Device to get the property of
 325  * @propname: Name of the property
 326  * @val: The values are stored here or %NULL to return the number of values
 327  * @nval: Size of the @val array
 328  *
 329  * Function reads an array of u32 properties with @propname from the device
 330  * firmware description and stores them to @val if found.
 331  *
 332  * Return: number of values if @val was %NULL,
 333  *         %0 if the property was found (success),
 334  *         %-EINVAL if given arguments are not valid,
 335  *         %-ENODATA if the property does not have a value,
 336  *         %-EPROTO if the property is not an array of numbers,
 337  *         %-EOVERFLOW if the size of the property is not as expected.
 338  *         %-ENXIO if no suitable firmware interface is present.
 339  */
 340 int device_property_read_u32_array(struct device *dev, const char *propname,
 341                                    u32 *val, size_t nval)
 342 {
 343         return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval);
 344 }
 345 EXPORT_SYMBOL_GPL(device_property_read_u32_array);
 346
 347 /**
 348  * device_property_read_u64_array - return a u64 array property of a device
 349  * @dev: Device to get the property of
 350  * @propname: Name of the property
 351  * @val: The values are stored here or %NULL to return the number of values
 352  * @nval: Size of the @val array
 353  *
 354  * Function reads an array of u64 properties with @propname from the device
 355  * firmware description and stores them to @val if found.
 356  *
 357  * Return: number of values if @val was %NULL,
 358  *         %0 if the property was found (success),
 359  *         %-EINVAL if given arguments are not valid,
 360  *         %-ENODATA if the property does not have a value,
 361  *         %-EPROTO if the property is not an array of numbers,
 362  *         %-EOVERFLOW if the size of the property is not as expected.
 363  *         %-ENXIO if no suitable firmware interface is present.
 364  */
 365 int device_property_read_u64_array(struct device *dev, const char *propname,
 366                                    u64 *val, size_t nval)
 367 {
 368         return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval);
 369 }
 370 EXPORT_SYMBOL_GPL(device_property_read_u64_array);
 371
 372 /**
 373  * device_property_read_string_array - return a string array property of device
 374  * @dev: Device to get the property of
 375  * @propname: Name of the property
 376  * @val: The values are stored here or %NULL to return the number of values
 377  * @nval: Size of the @val array
 378  *
 379  * Function reads an array of string properties with @propname from the device
 380  * firmware description and stores them to @val if found.
 381  *
 382  * Return: number of values read on success if @val is non-NULL,
 383  *         number of values available on success if @val is NULL,
 384  *         %-EINVAL if given arguments are not valid,
 385  *         %-ENODATA if the property does not have a value,
 386  *         %-EPROTO or %-EILSEQ if the property is not an array of strings,
 387  *         %-EOVERFLOW if the size of the property is not as expected.
 388  *         %-ENXIO if no suitable firmware interface is present.
 389  */
 390 int device_property_read_string_array(struct device *dev, const char *propname,
 391                                       const char **val, size_t nval)
 392 {
 393         return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval);
 394 }
 395 EXPORT_SYMBOL_GPL(device_property_read_string_array);
 396
 397 /**
 398  * device_property_read_string - return a string property of a device
 399  * @dev: Device to get the property of
 400  * @propname: Name of the property
 401  * @val: The value is stored here
 402  *
 403  * Function reads property @propname from the device firmware description and
 404  * stores the value into @val if found. The value is checked to be a string.
 405  *
 406  * Return: %0 if the property was found (success),
 407  *         %-EINVAL if given arguments are not valid,
 408  *         %-ENODATA if the property does not have a value,
 409  *         %-EPROTO or %-EILSEQ if the property type is not a string.
 410  *         %-ENXIO if no suitable firmware interface is present.
 411  */
 412 int device_property_read_string(struct device *dev, const char *propname,
 413                                 const char **val)
 414 {
 415         return fwnode_property_read_string(dev_fwnode(dev), propname, val);
 416 }
 417 EXPORT_SYMBOL_GPL(device_property_read_string);
 418
 419 /**
 420  * device_property_match_string - find a string in an array and return index
 421  * @dev: Device to get the property of
 422  * @propname: Name of the property holding the array
 423  * @string: String to look for
 424  *
 425  * Find a given string in a string array and if it is found return the
 426  * index back.
 427  *
 428  * Return: %0 if the property was found (success),
 429  *         %-EINVAL if given arguments are not valid,
 430  *         %-ENODATA if the property does not have a value,
 431  *         %-EPROTO if the property is not an array of strings,
 432  *         %-ENXIO if no suitable firmware interface is present.
 433  */
 434 int device_property_match_string(struct device *dev, const char *propname,
 435                                  const char *string)
 436 {
 437         return fwnode_property_match_string(dev_fwnode(dev), propname, string);
 438 }
 439 EXPORT_SYMBOL_GPL(device_property_match_string);
 440
 441 static int fwnode_property_read_int_array(const struct fwnode_handle *fwnode,
 442                                           const char *propname,
 443                                           unsigned int elem_size, void *val,
 444                                           size_t nval)
 445 {
 446         int ret;
 447
 448         ret = fwnode_call_int_op(fwnode, property_read_int_array, propname,
 449                                  elem_size, val, nval);
 450         if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&
 451             !IS_ERR_OR_NULL(fwnode->secondary))
 452                 ret = fwnode_call_int_op(
 453                         fwnode->secondary, property_read_int_array, propname,
 454                         elem_size, val, nval);
 455
 456         return ret;
 457 }
 458
 459 /**
 460  * fwnode_property_read_u8_array - return a u8 array property of firmware node
 461  * @fwnode: Firmware node to get the property of
 462  * @propname: Name of the property
 463  * @val: The values are stored here or %NULL to return the number of values
 464  * @nval: Size of the @val array
 465  *
 466  * Read an array of u8 properties with @propname from @fwnode and stores them to
 467  * @val if found.
 468  *
 469  * Return: number of values if @val was %NULL,
 470  *         %0 if the property was found (success),
 471  *         %-EINVAL if given arguments are not valid,
 472  *         %-ENODATA if the property does not have a value,
 473  *         %-EPROTO if the property is not an array of numbers,
 474  *         %-EOVERFLOW if the size of the property is not as expected,
 475  *         %-ENXIO if no suitable firmware interface is present.
 476  */
 477 int fwnode_property_read_u8_array(const struct fwnode_handle *fwnode,
 478                                   const char *propname, u8 *val, size_t nval)
 479 {
 480         return fwnode_property_read_int_array(fwnode, propname, sizeof(u8),
 481                                               val, nval);
 482 }
 483 EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
 484
 485 /**
 486  * fwnode_property_read_u16_array - return a u16 array property of firmware node
 487  * @fwnode: Firmware node to get the property of
 488  * @propname: Name of the property
 489  * @val: The values are stored here or %NULL to return the number of values
 490  * @nval: Size of the @val array
 491  *
 492  * Read an array of u16 properties with @propname from @fwnode and store them to
 493  * @val if found.
 494  *
 495  * Return: number of values if @val was %NULL,
 496  *         %0 if the property was found (success),
 497  *         %-EINVAL if given arguments are not valid,
 498  *         %-ENODATA if the property does not have a value,
 499  *         %-EPROTO if the property is not an array of numbers,
 500  *         %-EOVERFLOW if the size of the property is not as expected,
 501  *         %-ENXIO if no suitable firmware interface is present.
 502  */
 503 int fwnode_property_read_u16_array(const struct fwnode_handle *fwnode,
 504                                    const char *propname, u16 *val, size_t nval)
 505 {
 506         return fwnode_property_read_int_array(fwnode, propname, sizeof(u16),
 507                                               val, nval);
 508 }
 509 EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
 510
 511 /**
 512  * fwnode_property_read_u32_array - return a u32 array property of firmware node
 513  * @fwnode: Firmware node to get the property of
 514  * @propname: Name of the property
 515  * @val: The values are stored here or %NULL to return the number of values
 516  * @nval: Size of the @val array
 517  *
 518  * Read an array of u32 properties with @propname from @fwnode store them to
 519  * @val if found.
 520  *
 521  * Return: number of values if @val was %NULL,
 522  *         %0 if the property was found (success),
 523  *         %-EINVAL if given arguments are not valid,
 524  *         %-ENODATA if the property does not have a value,
 525  *         %-EPROTO if the property is not an array of numbers,
 526  *         %-EOVERFLOW if the size of the property is not as expected,
 527  *         %-ENXIO if no suitable firmware interface is present.
 528  */
 529 int fwnode_property_read_u32_array(const struct fwnode_handle *fwnode,
 530                                    const char *propname, u32 *val, size_t nval)
 531 {
 532         return fwnode_property_read_int_array(fwnode, propname, sizeof(u32),
 533                                               val, nval);
 534 }
 535 EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
 536
 537 /**
 538  * fwnode_property_read_u64_array - return a u64 array property firmware node
 539  * @fwnode: Firmware node to get the property of
 540  * @propname: Name of the property
 541  * @val: The values are stored here or %NULL to return the number of values
 542  * @nval: Size of the @val array
 543  *
 544  * Read an array of u64 properties with @propname from @fwnode and store them to
 545  * @val if found.
 546  *
 547  * Return: number of values if @val was %NULL,
 548  *         %0 if the property was found (success),
 549  *         %-EINVAL if given arguments are not valid,
 550  *         %-ENODATA if the property does not have a value,
 551  *         %-EPROTO if the property is not an array of numbers,
 552  *         %-EOVERFLOW if the size of the property is not as expected,
 553  *         %-ENXIO if no suitable firmware interface is present.
 554  */
 555 int fwnode_property_read_u64_array(const struct fwnode_handle *fwnode,
 556                                    const char *propname, u64 *val, size_t nval)
 557 {
 558         return fwnode_property_read_int_array(fwnode, propname, sizeof(u64),
 559                                               val, nval);
 560 }
 561 EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
 562
 563 /**
 564  * fwnode_property_read_string_array - return string array property of a node
 565  * @fwnode: Firmware node to get the property of
 566  * @propname: Name of the property
 567  * @val: The values are stored here or %NULL to return the number of values
 568  * @nval: Size of the @val array
 569  *
 570  * Read an string list property @propname from the given firmware node and store
 571  * them to @val if found.
 572  *
 573  * Return: number of values read on success if @val is non-NULL,
 574  *         number of values available on success if @val is NULL,
 575  *         %-EINVAL if given arguments are not valid,
 576  *         %-ENODATA if the property does not have a value,
 577  *         %-EPROTO or %-EILSEQ if the property is not an array of strings,
 578  *         %-EOVERFLOW if the size of the property is not as expected,
 579  *         %-ENXIO if no suitable firmware interface is present.
 580  */
 581 int fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
 582                                       const char *propname, const char **val,
 583                                       size_t nval)
 584 {
 585         int ret;
 586
 587         ret = fwnode_call_int_op(fwnode, property_read_string_array, propname,
 588                                  val, nval);
 589         if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&
 590             !IS_ERR_OR_NULL(fwnode->secondary))
 591                 ret = fwnode_call_int_op(fwnode->secondary,
 592                                          property_read_string_array, propname,
 593                                          val, nval);
 594         return ret;
 595 }
 596 EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
 597
 598 /**
 599  * fwnode_property_read_string - return a string property of a firmware node
 600  * @fwnode: Firmware node to get the property of
 601  * @propname: Name of the property
 602  * @val: The value is stored here
 603  *
 604  * Read property @propname from the given firmware node and store the value into
 605  * @val if found.  The value is checked to be a string.
 606  *
 607  * Return: %0 if the property was found (success),
 608  *         %-EINVAL if given arguments are not valid,
 609  *         %-ENODATA if the property does not have a value,
 610  *         %-EPROTO or %-EILSEQ if the property is not a string,
 611  *         %-ENXIO if no suitable firmware interface is present.
 612  */
 613 int fwnode_property_read_string(const struct fwnode_handle *fwnode,
 614                                 const char *propname, const char **val)
 615 {
 616         int ret = fwnode_property_read_string_array(fwnode, propname, val, 1);
 617
 618         return ret < 0 ? ret : 0;
 619 }
 620 EXPORT_SYMBOL_GPL(fwnode_property_read_string);
 621
 622 /**
 623  * fwnode_property_match_string - find a string in an array and return index
 624  * @fwnode: Firmware node to get the property of
 625  * @propname: Name of the property holding the array
 626  * @string: String to look for
 627  *
 628  * Find a given string in a string array and if it is found return the
 629  * index back.
 630  *
 631  * Return: %0 if the property was found (success),
 632  *         %-EINVAL if given arguments are not valid,
 633  *         %-ENODATA if the property does not have a value,
 634  *         %-EPROTO if the property is not an array of strings,
 635  *         %-ENXIO if no suitable firmware interface is present.
 636  */
 637 int fwnode_property_match_string(const struct fwnode_handle *fwnode,
 638         const char *propname, const char *string)
 639 {
 640         const char **values;
 641         int nval, ret;
 642
 643         nval = fwnode_property_read_string_array(fwnode, propname, NULL, 0);
 644         if (nval < 0)
 645                 return nval;
 646
 647         if (nval == 0)
 648                 return -ENODATA;
 649
 650         values = kcalloc(nval, sizeof(*values), GFP_KERNEL);
 651         if (!values)
 652                 return -ENOMEM;
 653
 654         ret = fwnode_property_read_string_array(fwnode, propname, values, nval);
 655         if (ret < 0)
 656                 goto out;
 657
 658         ret = match_string(values, nval, string);
 659         if (ret < 0)
 660                 ret = -ENODATA;
 661 out:
 662         kfree(values);
 663         return ret;
 664 }
 665 EXPORT_SYMBOL_GPL(fwnode_property_match_string);
 666
 667 /**
 668  * fwnode_property_get_reference_args() - Find a reference with arguments
 669  * @fwnode:     Firmware node where to look for the reference
 670  * @prop:       The name of the property
 671  * @nargs_prop: The name of the property telling the number of
 672  *              arguments in the referred node. NULL if @nargs is known,
 673  *              otherwise @nargs is ignored. Only relevant on OF.
 674  * @nargs:      Number of arguments. Ignored if @nargs_prop is non-NULL.
 675  * @index:      Index of the reference, from zero onwards.
 676  * @args:       Result structure with reference and integer arguments.
 677  *
 678  * Obtain a reference based on a named property in an fwnode, with
 679  * integer arguments.
 680  *
 681  * Caller is responsible to call fwnode_handle_put() on the returned
 682  * args->fwnode pointer.
 683  *
 684  * Returns: %0 on success
 685  *          %-ENOENT when the index is out of bounds, the index has an empty
 686  *                   reference or the property was not found
 687  *          %-EINVAL on parse error
 688  */
 689 int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode,
 690                                        const char *prop, const char *nargs_prop,
 691                                        unsigned int nargs, unsigned int index,
 692                                        struct fwnode_reference_args *args)
 693 {
 694         return fwnode_call_int_op(fwnode, get_reference_args, prop, nargs_prop,
 695                                   nargs, index, args);
 696 }
 697 EXPORT_SYMBOL_GPL(fwnode_property_get_reference_args);
 698
 699 static void property_entry_free_data(const struct property_entry *p)
 700 {
 701         size_t i, nval;
 702
 703         if (p->is_array) {
 704                 if (p->is_string && p->pointer.str) {
 705                         nval = p->length / sizeof(const char *);
 706                         for (i = 0; i < nval; i++)
 707                                 kfree(p->pointer.str[i]);
 708                 }
 709                 kfree(p->pointer.raw_data);
 710         } else if (p->is_string) {
 711                 kfree(p->value.str);
 712         }
 713         kfree(p->name);
 714 }
 715
 716 static int property_copy_string_array(struct property_entry *dst,
 717                                       const struct property_entry *src)
 718 {
 719         char **d;
 720         size_t nval = src->length / sizeof(*d);
 721         int i;
 722
 723         d = kcalloc(nval, sizeof(*d), GFP_KERNEL);
 724         if (!d)
 725                 return -ENOMEM;
 726
 727         for (i = 0; i < nval; i++) {
 728                 d[i] = kstrdup(src->pointer.str[i], GFP_KERNEL);
 729                 if (!d[i] && src->pointer.str[i]) {
 730                         while (--i >= 0)
 731                                 kfree(d[i]);
 732                         kfree(d);
 733                         return -ENOMEM;
 734                 }
 735         }
 736
 737         dst->pointer.raw_data = d;
 738         return 0;
 739 }
 740
 741 static int property_entry_copy_data(struct property_entry *dst,
 742                                     const struct property_entry *src)
 743 {
 744         int error;
 745
 746         if (src->is_array) {
 747                 if (!src->length)
 748                         return -ENODATA;
 749
 750                 if (src->is_string) {
 751                         error = property_copy_string_array(dst, src);
 752                         if (error)
 753                                 return error;
 754                 } else {
 755                         dst->pointer.raw_data = kmemdup(src->pointer.raw_data,
 756                                                         src->length, GFP_KERNEL);
 757                         if (!dst->pointer.raw_data)
 758                                 return -ENOMEM;
 759                 }
 760         } else if (src->is_string) {
 761                 dst->value.str = kstrdup(src->value.str, GFP_KERNEL);
 762                 if (!dst->value.str && src->value.str)
 763                         return -ENOMEM;
 764         } else {
 765                 dst->value.raw_data = src->value.raw_data;
 766         }
 767
 768         dst->length = src->length;
 769         dst->is_array = src->is_array;
 770         dst->is_string = src->is_string;
 771
 772         dst->name = kstrdup(src->name, GFP_KERNEL);
 773         if (!dst->name)
 774                 goto out_free_data;
 775
 776         return 0;
 777
 778 out_free_data:
 779         property_entry_free_data(dst);
 780         return -ENOMEM;
 781 }
 782
 783 /**
 784  * property_entries_dup - duplicate array of properties
 785  * @properties: array of properties to copy
 786  *
 787  * This function creates a deep copy of the given NULL-terminated array
 788  * of property entries.
 789  */
 790 struct property_entry *
 791 property_entries_dup(const struct property_entry *properties)
 792 {
 793         struct property_entry *p;
 794         int i, n = 0;
 795
 796         while (properties[n].name)
 797                 n++;
 798
 799         p = kcalloc(n + 1, sizeof(*p), GFP_KERNEL);
 800         if (!p)
 801                 return ERR_PTR(-ENOMEM);
 802
 803         for (i = 0; i < n; i++) {
 804                 int ret = property_entry_copy_data(&p[i], &properties[i]);
 805                 if (ret) {
 806                         while (--i >= 0)
 807                                 property_entry_free_data(&p[i]);
 808                         kfree(p);
 809                         return ERR_PTR(ret);
 810                 }
 811         }
 812
 813         return p;
 814 }
 815 EXPORT_SYMBOL_GPL(property_entries_dup);
 816
 817 /**
 818  * property_entries_free - free previously allocated array of properties
 819  * @properties: array of properties to destroy
 820  *
 821  * This function frees given NULL-terminated array of property entries,
 822  * along with their data.
 823  */
 824 void property_entries_free(const struct property_entry *properties)
 825 {
 826         const struct property_entry *p;
 827
 828         for (p = properties; p->name; p++)
 829                 property_entry_free_data(p);
 830
 831         kfree(properties);
 832 }
 833 EXPORT_SYMBOL_GPL(property_entries_free);
 834
 835 /**
 836  * pset_free_set - releases memory allocated for copied property set
 837  * @pset: Property set to release
 838  *
 839  * Function takes previously copied property set and releases all the
 840  * memory allocated to it.
 841  */
 842 static void pset_free_set(struct property_set *pset)
 843 {
 844         if (!pset)
 845                 return;
 846
 847         property_entries_free(pset->properties);
 848         kfree(pset);
 849 }
 850
 851 /**
 852  * pset_copy_set - copies property set
 853  * @pset: Property set to copy
 854  *
 855  * This function takes a deep copy of the given property set and returns
 856  * pointer to the copy. Call device_free_property_set() to free resources
 857  * allocated in this function.
 858  *
 859  * Return: Pointer to the new property set or error pointer.
 860  */
 861 static struct property_set *pset_copy_set(const struct property_set *pset)
 862 {
 863         struct property_entry *properties;
 864         struct property_set *p;
 865
 866         p = kzalloc(sizeof(*p), GFP_KERNEL);
 867         if (!p)
 868                 return ERR_PTR(-ENOMEM);
 869
 870         properties = property_entries_dup(pset->properties);
 871         if (IS_ERR(properties)) {
 872                 kfree(p);
 873                 return ERR_CAST(properties);
 874         }
 875
 876         p->properties = properties;
 877         return p;
 878 }
 879
 880 /**
 881  * device_remove_properties - Remove properties from a device object.
 882  * @dev: Device whose properties to remove.
 883  *
 884  * The function removes properties previously associated to the device
 885  * secondary firmware node with device_add_properties(). Memory allocated
 886  * to the properties will also be released.
 887  */
 888 void device_remove_properties(struct device *dev)
 889 {
 890         struct fwnode_handle *fwnode;
 891         struct property_set *pset;
 892
 893         fwnode = dev_fwnode(dev);
 894         if (!fwnode)
 895                 return;
 896         /*
 897          * Pick either primary or secondary node depending which one holds
 898          * the pset. If there is no real firmware node (ACPI/DT) primary
 899          * will hold the pset.
 900          */
 901         pset = to_pset_node(fwnode);
 902         if (pset) {
 903                 set_primary_fwnode(dev, NULL);
 904         } else {
 905                 pset = to_pset_node(fwnode->secondary);
 906                 if (pset && dev == pset->dev)
 907                         set_secondary_fwnode(dev, NULL);
 908         }
 909         if (pset && dev == pset->dev)
 910                 pset_free_set(pset);
 911 }
 912 EXPORT_SYMBOL_GPL(device_remove_properties);
 913
 914 /**
 915  * device_add_properties - Add a collection of properties to a device object.
 916  * @dev: Device to add properties to.
 917  * @properties: Collection of properties to add.
 918  *
 919  * Associate a collection of device properties represented by @properties with
 920  * @dev as its secondary firmware node. The function takes a copy of
 921  * @properties.
 922  */
 923 int device_add_properties(struct device *dev,
 924                           const struct property_entry *properties)
 925 {
 926         struct property_set *p, pset;
 927
 928         if (!properties)
 929                 return -EINVAL;
 930
 931         pset.properties = properties;
 932
 933         p = pset_copy_set(&pset);
 934         if (IS_ERR(p))
 935                 return PTR_ERR(p);
 936
 937         p->fwnode.ops = &pset_fwnode_ops;
 938         set_secondary_fwnode(dev, &p->fwnode);
 939         p->dev = dev;
 940         return 0;
 941 }
 942 EXPORT_SYMBOL_GPL(device_add_properties);
 943
 944 /**
 945  * fwnode_get_next_parent - Iterate to the node's parent
 946  * @fwnode: Firmware whose parent is retrieved
 947  *
 948  * This is like fwnode_get_parent() except that it drops the refcount
 949  * on the passed node, making it suitable for iterating through a
 950  * node's parents.
 951  *
 952  * Returns a node pointer with refcount incremented, use
 953  * fwnode_handle_node() on it when done.
 954  */
 955 struct fwnode_handle *fwnode_get_next_parent(struct fwnode_handle *fwnode)
 956 {
 957         struct fwnode_handle *parent = fwnode_get_parent(fwnode);
 958
 959         fwnode_handle_put(fwnode);
 960
 961         return parent;
 962 }
 963 EXPORT_SYMBOL_GPL(fwnode_get_next_parent);
 964
 965 /**
 966  * fwnode_get_parent - Return parent firwmare node
 967  * @fwnode: Firmware whose parent is retrieved
 968  *
 969  * Return parent firmware node of the given node if possible or %NULL if no
 970  * parent was available.
 971  */
 972 struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode)
 973 {
 974         return fwnode_call_ptr_op(fwnode, get_parent);
 975 }
 976 EXPORT_SYMBOL_GPL(fwnode_get_parent);
 977
 978 /**
 979  * fwnode_get_next_child_node - Return the next child node handle for a node
 980  * @fwnode: Firmware node to find the next child node for.
 981  * @child: Handle to one of the node's child nodes or a %NULL handle.
 982  */
 983 struct fwnode_handle *
 984 fwnode_get_next_child_node(const struct fwnode_handle *fwnode,
 985                            struct fwnode_handle *child)
 986 {
 987         return fwnode_call_ptr_op(fwnode, get_next_child_node, child);
 988 }
 989 EXPORT_SYMBOL_GPL(fwnode_get_next_child_node);
 990
 991 /**
 992  * fwnode_get_next_available_child_node - Return the next
 993  * available child node handle for a node
 994  * @fwnode: Firmware node to find the next child node for.
 995  * @child: Handle to one of the node's child nodes or a %NULL handle.
 996  */
 997 struct fwnode_handle *
 998 fwnode_get_next_available_child_node(const struct fwnode_handle *fwnode,
 999                                      struct fwnode_handle *child)
1000 {
1001         struct fwnode_handle *next_child = child;
1002
1003         if (!fwnode)
1004                 return NULL;
1005
1006         do {
1007                 next_child = fwnode_get_next_child_node(fwnode, next_child);
1008
1009                 if (!next_child || fwnode_device_is_available(next_child))
1010                         break;
1011         } while (next_child);
1012
1013         return next_child;
1014 }
1015 EXPORT_SYMBOL_GPL(fwnode_get_next_available_child_node);
1016
1017 /**
1018  * device_get_next_child_node - Return the next child node handle for a device
1019  * @dev: Device to find the next child node for.
1020  * @child: Handle to one of the device's child nodes or a null handle.
1021  */
1022 struct fwnode_handle *device_get_next_child_node(struct device *dev,
1023                                                  struct fwnode_handle *child)
1024 {
1025         struct acpi_device *adev = ACPI_COMPANION(dev);
1026         struct fwnode_handle *fwnode = NULL;
1027
1028         if (dev->of_node)
1029                 fwnode = &dev->of_node->fwnode;
1030         else if (adev)
1031                 fwnode = acpi_fwnode_handle(adev);
1032
1033         return fwnode_get_next_child_node(fwnode, child);
1034 }
1035 EXPORT_SYMBOL_GPL(device_get_next_child_node);
1036
1037 /**
1038  * fwnode_get_named_child_node - Return first matching named child node handle
1039  * @fwnode: Firmware node to find the named child node for.
1040  * @childname: String to match child node name against.
1041  */
1042 struct fwnode_handle *
1043 fwnode_get_named_child_node(const struct fwnode_handle *fwnode,
1044                             const char *childname)
1045 {
1046         return fwnode_call_ptr_op(fwnode, get_named_child_node, childname);
1047 }
1048 EXPORT_SYMBOL_GPL(fwnode_get_named_child_node);
1049
1050 /**
1051  * device_get_named_child_node - Return first matching named child node handle
1052  * @dev: Device to find the named child node for.
1053  * @childname: String to match child node name against.
1054  */
1055 struct fwnode_handle *device_get_named_child_node(struct device *dev,
1056                                                   const char *childname)
1057 {
1058         return fwnode_get_named_child_node(dev_fwnode(dev), childname);
1059 }
1060 EXPORT_SYMBOL_GPL(device_get_named_child_node);
1061
1062 /**
1063  * fwnode_handle_get - Obtain a reference to a device node
1064  * @fwnode: Pointer to the device node to obtain the reference to.
1065  *
1066  * Returns the fwnode handle.
1067  */
1068 struct fwnode_handle *fwnode_handle_get(struct fwnode_handle *fwnode)
1069 {
1070         if (!fwnode_has_op(fwnode, get))
1071                 return fwnode;
1072
1073         return fwnode_call_ptr_op(fwnode, get);
1074 }
1075 EXPORT_SYMBOL_GPL(fwnode_handle_get);
1076
1077 /**
1078  * fwnode_handle_put - Drop reference to a device node
1079  * @fwnode: Pointer to the device node to drop the reference to.
1080  *
1081  * This has to be used when terminating device_for_each_child_node() iteration
1082  * with break or return to prevent stale device node references from being left
1083  * behind.
1084  */
1085 void fwnode_handle_put(struct fwnode_handle *fwnode)
1086 {
1087         fwnode_call_void_op(fwnode, put);
1088 }
1089 EXPORT_SYMBOL_GPL(fwnode_handle_put);
1090
1091 /**
1092  * fwnode_device_is_available - check if a device is available for use
1093  * @fwnode: Pointer to the fwnode of the device.
1094  */
1095 bool fwnode_device_is_available(const struct fwnode_handle *fwnode)
1096 {
1097         return fwnode_call_bool_op(fwnode, device_is_available);
1098 }
1099 EXPORT_SYMBOL_GPL(fwnode_device_is_available);
1100
1101 /**
1102  * device_get_child_node_count - return the number of child nodes for device
1103  * @dev: Device to cound the child nodes for
1104  */
1105 unsigned int device_get_child_node_count(struct device *dev)
1106 {
1107         struct fwnode_handle *child;
1108         unsigned int count = 0;
1109
1110         device_for_each_child_node(dev, child)
1111                 count++;
1112
1113         return count;
1114 }
1115 EXPORT_SYMBOL_GPL(device_get_child_node_count);
1116
1117 bool device_dma_supported(struct device *dev)
1118 {
1119         /* For DT, this is always supported.
1120          * For ACPI, this depends on CCA, which
1121          * is determined by the acpi_dma_supported().
1122          */
1123         if (IS_ENABLED(CONFIG_OF) && dev->of_node)
1124                 return true;
1125
1126         return acpi_dma_supported(ACPI_COMPANION(dev));
1127 }
1128 EXPORT_SYMBOL_GPL(device_dma_supported);
1129
1130 enum dev_dma_attr device_get_dma_attr(struct device *dev)
1131 {
1132         enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED;
1133
1134         if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
1135                 if (of_dma_is_coherent(dev->of_node))
1136                         attr = DEV_DMA_COHERENT;
1137                 else
1138                         attr = DEV_DMA_NON_COHERENT;
1139         } else
1140                 attr = acpi_get_dma_attr(ACPI_COMPANION(dev));
1141
1142         return attr;
1143 }
1144 EXPORT_SYMBOL_GPL(device_get_dma_attr);
1145
1146 /**
1147  * fwnode_get_phy_mode - Get phy mode for given firmware node
1148  * @fwnode:     Pointer to the given node
1149  *
1150  * The function gets phy interface string from property 'phy-mode' or
1151  * 'phy-connection-type', and return its index in phy_modes table, or errno in
1152  * error case.
1153  */
1154 int fwnode_get_phy_mode(struct fwnode_handle *fwnode)
1155 {
1156         const char *pm;
1157         int err, i;
1158
1159         err = fwnode_property_read_string(fwnode, "phy-mode", &pm);
1160         if (err < 0)
1161                 err = fwnode_property_read_string(fwnode,
1162                                                   "phy-connection-type", &pm);
1163         if (err < 0)
1164                 return err;
1165
1166         for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++)
1167                 if (!strcasecmp(pm, phy_modes(i)))
1168                         return i;
1169
1170         return -ENODEV;
1171 }
1172 EXPORT_SYMBOL_GPL(fwnode_get_phy_mode);
1173
1174 /**
1175  * device_get_phy_mode - Get phy mode for given device
1176  * @dev:        Pointer to the given device
1177  *
1178  * The function gets phy interface string from property 'phy-mode' or
1179  * 'phy-connection-type', and return its index in phy_modes table, or errno in
1180  * error case.
1181  */
1182 int device_get_phy_mode(struct device *dev)
1183 {
1184         return fwnode_get_phy_mode(dev_fwnode(dev));
1185 }
1186 EXPORT_SYMBOL_GPL(device_get_phy_mode);
1187
1188 static void *fwnode_get_mac_addr(struct fwnode_handle *fwnode,
1189                                  const char *name, char *addr,
1190                                  int alen)
1191 {
1192         int ret = fwnode_property_read_u8_array(fwnode, name, addr, alen);
1193
1194         if (ret == 0 && alen == ETH_ALEN && is_valid_ether_addr(addr))
1195                 return addr;
1196         return NULL;
1197 }
1198
1199 /**
1200  * fwnode_get_mac_address - Get the MAC from the firmware node
1201  * @fwnode:     Pointer to the firmware node
1202  * @addr:       Address of buffer to store the MAC in
1203  * @alen:       Length of the buffer pointed to by addr, should be ETH_ALEN
1204  *
1205  * Search the firmware node for the best MAC address to use.  'mac-address' is
1206  * checked first, because that is supposed to contain to "most recent" MAC
1207  * address. If that isn't set, then 'local-mac-address' is checked next,
1208  * because that is the default address.  If that isn't set, then the obsolete
1209  * 'address' is checked, just in case we're using an old device tree.
1210  *
1211  * Note that the 'address' property is supposed to contain a virtual address of
1212  * the register set, but some DTS files have redefined that property to be the
1213  * MAC address.
1214  *
1215  * All-zero MAC addresses are rejected, because those could be properties that
1216  * exist in the firmware tables, but were not updated by the firmware.  For
1217  * example, the DTS could define 'mac-address' and 'local-mac-address', with
1218  * zero MAC addresses.  Some older U-Boots only initialized 'local-mac-address'.
1219  * In this case, the real MAC is in 'local-mac-address', and 'mac-address'
1220  * exists but is all zeros.
1221 */
1222 void *fwnode_get_mac_address(struct fwnode_handle *fwnode, char *addr, int alen)
1223 {
1224         char *res;
1225
1226         res = fwnode_get_mac_addr(fwnode, "mac-address", addr, alen);
1227         if (res)
1228                 return res;
1229
1230         res = fwnode_get_mac_addr(fwnode, "local-mac-address", addr, alen);
1231         if (res)
1232                 return res;
1233
1234         return fwnode_get_mac_addr(fwnode, "address", addr, alen);
1235 }
1236 EXPORT_SYMBOL(fwnode_get_mac_address);
1237
1238 /**
1239  * device_get_mac_address - Get the MAC for a given device
1240  * @dev:        Pointer to the device
1241  * @addr:       Address of buffer to store the MAC in
1242  * @alen:       Length of the buffer pointed to by addr, should be ETH_ALEN
1243  */
1244 void *device_get_mac_address(struct device *dev, char *addr, int alen)
1245 {
1246         return fwnode_get_mac_address(dev_fwnode(dev), addr, alen);
1247 }
1248 EXPORT_SYMBOL(device_get_mac_address);
1249
1250 /**
1251  * fwnode_irq_get - Get IRQ directly from a fwnode
1252  * @fwnode:     Pointer to the firmware node
1253  * @index:      Zero-based index of the IRQ
1254  *
1255  * Returns Linux IRQ number on success. Other values are determined
1256  * accordingly to acpi_/of_ irq_get() operation.
1257  */
1258 int fwnode_irq_get(struct fwnode_handle *fwnode, unsigned int index)
1259 {
1260         struct device_node *of_node = to_of_node(fwnode);
1261         struct resource res;
1262         int ret;
1263
1264         if (IS_ENABLED(CONFIG_OF) && of_node)
1265                 return of_irq_get(of_node, index);
1266
1267         ret = acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode), index, &res);
1268         if (ret)
1269                 return ret;
1270
1271         return res.start;
1272 }
1273 EXPORT_SYMBOL(fwnode_irq_get);
1274
1275 /**
1276  * device_graph_get_next_endpoint - Get next endpoint firmware node
1277  * @fwnode: Pointer to the parent firmware node
1278  * @prev: Previous endpoint node or %NULL to get the first
1279  *
1280  * Returns an endpoint firmware node pointer or %NULL if no more endpoints
1281  * are available.
1282  */
1283 struct fwnode_handle *
1284 fwnode_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
1285                                struct fwnode_handle *prev)
1286 {
1287         return fwnode_call_ptr_op(fwnode, graph_get_next_endpoint, prev);
1288 }
1289 EXPORT_SYMBOL_GPL(fwnode_graph_get_next_endpoint);
1290
1291 /**
1292  * fwnode_graph_get_port_parent - Return the device fwnode of a port endpoint
1293  * @endpoint: Endpoint firmware node of the port
1294  *
1295  * Return: the firmware node of the device the @endpoint belongs to.
1296  */
1297 struct fwnode_handle *
1298 fwnode_graph_get_port_parent(const struct fwnode_handle *endpoint)
1299 {
1300         struct fwnode_handle *port, *parent;
1301
1302         port = fwnode_get_parent(endpoint);
1303         parent = fwnode_call_ptr_op(port, graph_get_port_parent);
1304
1305         fwnode_handle_put(port);
1306
1307         return parent;
1308 }
1309 EXPORT_SYMBOL_GPL(fwnode_graph_get_port_parent);
1310
1311 /**
1312  * fwnode_graph_get_remote_port_parent - Return fwnode of a remote device
1313  * @fwnode: Endpoint firmware node pointing to the remote endpoint
1314  *
1315  * Extracts firmware node of a remote device the @fwnode points to.
1316  */
1317 struct fwnode_handle *
1318 fwnode_graph_get_remote_port_parent(const struct fwnode_handle *fwnode)
1319 {
1320         struct fwnode_handle *endpoint, *parent;
1321
1322         endpoint = fwnode_graph_get_remote_endpoint(fwnode);
1323         parent = fwnode_graph_get_port_parent(endpoint);
1324
1325         fwnode_handle_put(endpoint);
1326
1327         return parent;
1328 }
1329 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port_parent);
1330
1331 /**
1332  * fwnode_graph_get_remote_port - Return fwnode of a remote port
1333  * @fwnode: Endpoint firmware node pointing to the remote endpoint
1334  *
1335  * Extracts firmware node of a remote port the @fwnode points to.
1336  */
1337 struct fwnode_handle *
1338 fwnode_graph_get_remote_port(const struct fwnode_handle *fwnode)
1339 {
1340         return fwnode_get_next_parent(fwnode_graph_get_remote_endpoint(fwnode));
1341 }
1342 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port);
1343
1344 /**
1345  * fwnode_graph_get_remote_endpoint - Return fwnode of a remote endpoint
1346  * @fwnode: Endpoint firmware node pointing to the remote endpoint
1347  *
1348  * Extracts firmware node of a remote endpoint the @fwnode points to.
1349  */
1350 struct fwnode_handle *
1351 fwnode_graph_get_remote_endpoint(const struct fwnode_handle *fwnode)
1352 {
1353         return fwnode_call_ptr_op(fwnode, graph_get_remote_endpoint);
1354 }
1355 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_endpoint);
1356
1357 /**
1358  * fwnode_graph_get_remote_node - get remote parent node for given port/endpoint
1359  * @fwnode: pointer to parent fwnode_handle containing graph port/endpoint
1360  * @port_id: identifier of the parent port node
1361  * @endpoint_id: identifier of the endpoint node
1362  *
1363  * Return: Remote fwnode handle associated with remote endpoint node linked
1364  *         to @node. Use fwnode_node_put() on it when done.
1365  */
1366 struct fwnode_handle *
1367 fwnode_graph_get_remote_node(const struct fwnode_handle *fwnode, u32 port_id,
1368                              u32 endpoint_id)
1369 {
1370         struct fwnode_handle *endpoint = NULL;
1371
1372         while ((endpoint = fwnode_graph_get_next_endpoint(fwnode, endpoint))) {
1373                 struct fwnode_endpoint fwnode_ep;
1374                 struct fwnode_handle *remote;
1375                 int ret;
1376
1377                 ret = fwnode_graph_parse_endpoint(endpoint, &fwnode_ep);
1378                 if (ret < 0)
1379                         continue;
1380
1381                 if (fwnode_ep.port != port_id || fwnode_ep.id != endpoint_id)
1382                         continue;
1383
1384                 remote = fwnode_graph_get_remote_port_parent(endpoint);
1385                 if (!remote)
1386                         return NULL;
1387
1388                 return fwnode_device_is_available(remote) ? remote : NULL;
1389         }
1390
1391         return NULL;
1392 }
1393 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_node);
1394
1395 /**
1396  * fwnode_graph_parse_endpoint - parse common endpoint node properties
1397  * @fwnode: pointer to endpoint fwnode_handle
1398  * @endpoint: pointer to the fwnode endpoint data structure
1399  *
1400  * Parse @fwnode representing a graph endpoint node and store the
1401  * information in @endpoint. The caller must hold a reference to
1402  * @fwnode.
1403  */
1404 int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
1405                                 struct fwnode_endpoint *endpoint)
1406 {
1407         memset(endpoint, 0, sizeof(*endpoint));
1408
1409         return fwnode_call_int_op(fwnode, graph_parse_endpoint, endpoint);
1410 }
1411 EXPORT_SYMBOL(fwnode_graph_parse_endpoint);
1412
1413 const void *device_get_match_data(struct device *dev)
1414 {
1415         return fwnode_call_ptr_op(dev_fwnode(dev), device_get_match_data, dev);
1416 }
1417 EXPORT_SYMBOL_GPL(device_get_match_data);