drivers/base/property.c

   1 /*
   2  * property.c - Unified device property interface.
   3  *
   4  * Copyright (C) 2014, Intel Corporation
   5  * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
   6  *          Mika Westerberg <mika.westerberg@linux.intel.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/acpi.h>
  14 #include <linux/export.h>
  15 #include <linux/kernel.h>
  16 #include <linux/of.h>
  17 #include <linux/of_address.h>
  18 #include <linux/property.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/phy.h>
  21
  22 /**
  23  * device_add_property_set - Add a collection of properties to a device object.
  24  * @dev: Device to add properties to.
  25  * @pset: Collection of properties to add.
  26  *
  27  * Associate a collection of device properties represented by @pset with @dev
  28  * as its secondary firmware node.
  29  */
  30 void device_add_property_set(struct device *dev, struct property_set *pset)
  31 {
  32         if (!pset)
  33                 return;
  34
  35         pset->fwnode.type = FWNODE_PDATA;
  36         set_secondary_fwnode(dev, &pset->fwnode);
  37 }
  38 EXPORT_SYMBOL_GPL(device_add_property_set);
  39
  40 static inline bool is_pset(struct fwnode_handle *fwnode)
  41 {
  42         return fwnode && fwnode->type == FWNODE_PDATA;
  43 }
  44
  45 static inline struct property_set *to_pset(struct fwnode_handle *fwnode)
  46 {
  47         return is_pset(fwnode) ?
  48                 container_of(fwnode, struct property_set, fwnode) : NULL;
  49 }
  50
  51 static struct property_entry *pset_prop_get(struct property_set *pset,
  52                                             const char *name)
  53 {
  54         struct property_entry *prop;
  55
  56         if (!pset || !pset->properties)
  57                 return NULL;
  58
  59         for (prop = pset->properties; prop->name; prop++)
  60                 if (!strcmp(name, prop->name))
  61                         return prop;
  62
  63         return NULL;
  64 }
  65
  66 static int pset_prop_read_array(struct property_set *pset, const char *name,
  67                                 enum dev_prop_type type, void *val, size_t nval)
  68 {
  69         struct property_entry *prop;
  70         unsigned int item_size;
  71
  72         prop = pset_prop_get(pset, name);
  73         if (!prop)
  74                 return -ENODATA;
  75
  76         if (prop->type != type)
  77                 return -EPROTO;
  78
  79         if (!val)
  80                 return prop->nval;
  81
  82         if (prop->nval < nval)
  83                 return -EOVERFLOW;
  84
  85         switch (type) {
  86         case DEV_PROP_U8:
  87                 item_size = sizeof(u8);
  88                 break;
  89         case DEV_PROP_U16:
  90                 item_size = sizeof(u16);
  91                 break;
  92         case DEV_PROP_U32:
  93                 item_size = sizeof(u32);
  94                 break;
  95         case DEV_PROP_U64:
  96                 item_size = sizeof(u64);
  97                 break;
  98         case DEV_PROP_STRING:
  99                 item_size = sizeof(const char *);
 100                 break;
 101         default:
 102                 return -EINVAL;
 103         }
 104         memcpy(val, prop->value.raw_data, nval * item_size);
 105         return 0;
 106 }
 107
 108 static inline struct fwnode_handle *dev_fwnode(struct device *dev)
 109 {
 110         return IS_ENABLED(CONFIG_OF) && dev->of_node ?
 111                 &dev->of_node->fwnode : dev->fwnode;
 112 }
 113
 114 /**
 115  * device_property_present - check if a property of a device is present
 116  * @dev: Device whose property is being checked
 117  * @propname: Name of the property
 118  *
 119  * Check if property @propname is present in the device firmware description.
 120  */
 121 bool device_property_present(struct device *dev, const char *propname)
 122 {
 123         return fwnode_property_present(dev_fwnode(dev), propname);
 124 }
 125 EXPORT_SYMBOL_GPL(device_property_present);
 126
 127 /**
 128  * fwnode_property_present - check if a property of a firmware node is present
 129  * @fwnode: Firmware node whose property to check
 130  * @propname: Name of the property
 131  */
 132 bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname)
 133 {
 134         if (is_of_node(fwnode))
 135                 return of_property_read_bool(to_of_node(fwnode), propname);
 136         else if (is_acpi_node(fwnode))
 137                 return !acpi_dev_prop_get(to_acpi_node(fwnode), propname, NULL);
 138
 139         return !!pset_prop_get(to_pset(fwnode), propname);
 140 }
 141 EXPORT_SYMBOL_GPL(fwnode_property_present);
 142
 143 /**
 144  * device_property_read_u8_array - return a u8 array property of a device
 145  * @dev: Device to get the property of
 146  * @propname: Name of the property
 147  * @val: The values are stored here or %NULL to return the number of values
 148  * @nval: Size of the @val array
 149  *
 150  * Function reads an array of u8 properties with @propname from the device
 151  * firmware description and stores them to @val if found.
 152  *
 153  * Return: number of values if @val was %NULL,
 154  *         %0 if the property was found (success),
 155  *         %-EINVAL if given arguments are not valid,
 156  *         %-ENODATA if the property does not have a value,
 157  *         %-EPROTO if the property is not an array of numbers,
 158  *         %-EOVERFLOW if the size of the property is not as expected.
 159  *         %-ENXIO if no suitable firmware interface is present.
 160  */
 161 int device_property_read_u8_array(struct device *dev, const char *propname,
 162                                   u8 *val, size_t nval)
 163 {
 164         return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval);
 165 }
 166 EXPORT_SYMBOL_GPL(device_property_read_u8_array);
 167
 168 /**
 169  * device_property_read_u16_array - return a u16 array property of a device
 170  * @dev: Device to get the property of
 171  * @propname: Name of the property
 172  * @val: The values are stored here or %NULL to return the number of values
 173  * @nval: Size of the @val array
 174  *
 175  * Function reads an array of u16 properties with @propname from the device
 176  * firmware description and stores them to @val if found.
 177  *
 178  * Return: number of values if @val was %NULL,
 179  *         %0 if the property was found (success),
 180  *         %-EINVAL if given arguments are not valid,
 181  *         %-ENODATA if the property does not have a value,
 182  *         %-EPROTO if the property is not an array of numbers,
 183  *         %-EOVERFLOW if the size of the property is not as expected.
 184  *         %-ENXIO if no suitable firmware interface is present.
 185  */
 186 int device_property_read_u16_array(struct device *dev, const char *propname,
 187                                    u16 *val, size_t nval)
 188 {
 189         return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval);
 190 }
 191 EXPORT_SYMBOL_GPL(device_property_read_u16_array);
 192
 193 /**
 194  * device_property_read_u32_array - return a u32 array property of a device
 195  * @dev: Device to get the property of
 196  * @propname: Name of the property
 197  * @val: The values are stored here or %NULL to return the number of values
 198  * @nval: Size of the @val array
 199  *
 200  * Function reads an array of u32 properties with @propname from the device
 201  * firmware description and stores them to @val if found.
 202  *
 203  * Return: number of values if @val was %NULL,
 204  *         %0 if the property was found (success),
 205  *         %-EINVAL if given arguments are not valid,
 206  *         %-ENODATA if the property does not have a value,
 207  *         %-EPROTO if the property is not an array of numbers,
 208  *         %-EOVERFLOW if the size of the property is not as expected.
 209  *         %-ENXIO if no suitable firmware interface is present.
 210  */
 211 int device_property_read_u32_array(struct device *dev, const char *propname,
 212                                    u32 *val, size_t nval)
 213 {
 214         return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval);
 215 }
 216 EXPORT_SYMBOL_GPL(device_property_read_u32_array);
 217
 218 /**
 219  * device_property_read_u64_array - return a u64 array property of a device
 220  * @dev: Device to get the property of
 221  * @propname: Name of the property
 222  * @val: The values are stored here or %NULL to return the number of values
 223  * @nval: Size of the @val array
 224  *
 225  * Function reads an array of u64 properties with @propname from the device
 226  * firmware description and stores them to @val if found.
 227  *
 228  * Return: number of values if @val was %NULL,
 229  *         %0 if the property was found (success),
 230  *         %-EINVAL if given arguments are not valid,
 231  *         %-ENODATA if the property does not have a value,
 232  *         %-EPROTO if the property is not an array of numbers,
 233  *         %-EOVERFLOW if the size of the property is not as expected.
 234  *         %-ENXIO if no suitable firmware interface is present.
 235  */
 236 int device_property_read_u64_array(struct device *dev, const char *propname,
 237                                    u64 *val, size_t nval)
 238 {
 239         return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval);
 240 }
 241 EXPORT_SYMBOL_GPL(device_property_read_u64_array);
 242
 243 /**
 244  * device_property_read_string_array - return a string array property of device
 245  * @dev: Device to get the property of
 246  * @propname: Name of the property
 247  * @val: The values are stored here or %NULL to return the number of values
 248  * @nval: Size of the @val array
 249  *
 250  * Function reads an array of string properties with @propname from the device
 251  * firmware description and stores them to @val if found.
 252  *
 253  * Return: number of values if @val was %NULL,
 254  *         %0 if the property was found (success),
 255  *         %-EINVAL if given arguments are not valid,
 256  *         %-ENODATA if the property does not have a value,
 257  *         %-EPROTO or %-EILSEQ if the property is not an array of strings,
 258  *         %-EOVERFLOW if the size of the property is not as expected.
 259  *         %-ENXIO if no suitable firmware interface is present.
 260  */
 261 int device_property_read_string_array(struct device *dev, const char *propname,
 262                                       const char **val, size_t nval)
 263 {
 264         return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval);
 265 }
 266 EXPORT_SYMBOL_GPL(device_property_read_string_array);
 267
 268 /**
 269  * device_property_read_string - return a string property of a device
 270  * @dev: Device to get the property of
 271  * @propname: Name of the property
 272  * @val: The value is stored here
 273  *
 274  * Function reads property @propname from the device firmware description and
 275  * stores the value into @val if found. The value is checked to be a string.
 276  *
 277  * Return: %0 if the property was found (success),
 278  *         %-EINVAL if given arguments are not valid,
 279  *         %-ENODATA if the property does not have a value,
 280  *         %-EPROTO or %-EILSEQ if the property type is not a string.
 281  *         %-ENXIO if no suitable firmware interface is present.
 282  */
 283 int device_property_read_string(struct device *dev, const char *propname,
 284                                 const char **val)
 285 {
 286         return fwnode_property_read_string(dev_fwnode(dev), propname, val);
 287 }
 288 EXPORT_SYMBOL_GPL(device_property_read_string);
 289
 290 #define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \
 291         (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \
 292               : of_property_count_elems_of_size((node), (propname), sizeof(type))
 293
 294 #define FWNODE_PROP_READ_ARRAY(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \
 295 ({ \
 296         int _ret_; \
 297         if (is_of_node(_fwnode_)) \
 298                 _ret_ = OF_DEV_PROP_READ_ARRAY(to_of_node(_fwnode_), _propname_, \
 299                                                _type_, _val_, _nval_); \
 300         else if (is_acpi_node(_fwnode_)) \
 301                 _ret_ = acpi_dev_prop_read(to_acpi_node(_fwnode_), _propname_, \
 302                                            _proptype_, _val_, _nval_); \
 303         else if (is_pset(_fwnode_)) \
 304                 _ret_ = pset_prop_read_array(to_pset(_fwnode_), _propname_, \
 305                                              _proptype_, _val_, _nval_); \
 306         else \
 307                 _ret_ = -ENXIO; \
 308         _ret_; \
 309 })
 310
 311 /**
 312  * fwnode_property_read_u8_array - return a u8 array property of firmware node
 313  * @fwnode: Firmware node to get the property of
 314  * @propname: Name of the property
 315  * @val: The values are stored here or %NULL to return the number of values
 316  * @nval: Size of the @val array
 317  *
 318  * Read an array of u8 properties with @propname from @fwnode and stores them to
 319  * @val if found.
 320  *
 321  * Return: number of values if @val was %NULL,
 322  *         %0 if the property was found (success),
 323  *         %-EINVAL if given arguments are not valid,
 324  *         %-ENODATA if the property does not have a value,
 325  *         %-EPROTO if the property is not an array of numbers,
 326  *         %-EOVERFLOW if the size of the property is not as expected,
 327  *         %-ENXIO if no suitable firmware interface is present.
 328  */
 329 int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
 330                                   const char *propname, u8 *val, size_t nval)
 331 {
 332         return FWNODE_PROP_READ_ARRAY(fwnode, propname, u8, DEV_PROP_U8,
 333                                       val, nval);
 334 }
 335 EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
 336
 337 /**
 338  * fwnode_property_read_u16_array - return a u16 array property of firmware node
 339  * @fwnode: Firmware node to get the property of
 340  * @propname: Name of the property
 341  * @val: The values are stored here or %NULL to return the number of values
 342  * @nval: Size of the @val array
 343  *
 344  * Read an array of u16 properties with @propname from @fwnode and store them to
 345  * @val if found.
 346  *
 347  * Return: number of values if @val was %NULL,
 348  *         %0 if the property was found (success),
 349  *         %-EINVAL if given arguments are not valid,
 350  *         %-ENODATA if the property does not have a value,
 351  *         %-EPROTO if the property is not an array of numbers,
 352  *         %-EOVERFLOW if the size of the property is not as expected,
 353  *         %-ENXIO if no suitable firmware interface is present.
 354  */
 355 int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
 356                                    const char *propname, u16 *val, size_t nval)
 357 {
 358         return FWNODE_PROP_READ_ARRAY(fwnode, propname, u16, DEV_PROP_U16,
 359                                       val, nval);
 360 }
 361 EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
 362
 363 /**
 364  * fwnode_property_read_u32_array - return a u32 array property of firmware node
 365  * @fwnode: Firmware node to get the property of
 366  * @propname: Name of the property
 367  * @val: The values are stored here or %NULL to return the number of values
 368  * @nval: Size of the @val array
 369  *
 370  * Read an array of u32 properties with @propname from @fwnode store them to
 371  * @val if found.
 372  *
 373  * Return: number of values if @val was %NULL,
 374  *         %0 if the property was found (success),
 375  *         %-EINVAL if given arguments are not valid,
 376  *         %-ENODATA if the property does not have a value,
 377  *         %-EPROTO if the property is not an array of numbers,
 378  *         %-EOVERFLOW if the size of the property is not as expected,
 379  *         %-ENXIO if no suitable firmware interface is present.
 380  */
 381 int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
 382                                    const char *propname, u32 *val, size_t nval)
 383 {
 384         return FWNODE_PROP_READ_ARRAY(fwnode, propname, u32, DEV_PROP_U32,
 385                                       val, nval);
 386 }
 387 EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
 388
 389 /**
 390  * fwnode_property_read_u64_array - return a u64 array property firmware node
 391  * @fwnode: Firmware node to get the property of
 392  * @propname: Name of the property
 393  * @val: The values are stored here or %NULL to return the number of values
 394  * @nval: Size of the @val array
 395  *
 396  * Read an array of u64 properties with @propname from @fwnode and store them to
 397  * @val if found.
 398  *
 399  * Return: number of values if @val was %NULL,
 400  *         %0 if the property was found (success),
 401  *         %-EINVAL if given arguments are not valid,
 402  *         %-ENODATA if the property does not have a value,
 403  *         %-EPROTO if the property is not an array of numbers,
 404  *         %-EOVERFLOW if the size of the property is not as expected,
 405  *         %-ENXIO if no suitable firmware interface is present.
 406  */
 407 int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
 408                                    const char *propname, u64 *val, size_t nval)
 409 {
 410         return FWNODE_PROP_READ_ARRAY(fwnode, propname, u64, DEV_PROP_U64,
 411                                       val, nval);
 412 }
 413 EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
 414
 415 /**
 416  * fwnode_property_read_string_array - return string array property of a node
 417  * @fwnode: Firmware node to get the property of
 418  * @propname: Name of the property
 419  * @val: The values are stored here or %NULL to return the number of values
 420  * @nval: Size of the @val array
 421  *
 422  * Read an string list property @propname from the given firmware node and store
 423  * them to @val if found.
 424  *
 425  * Return: number of values if @val was %NULL,
 426  *         %0 if the property was found (success),
 427  *         %-EINVAL if given arguments are not valid,
 428  *         %-ENODATA if the property does not have a value,
 429  *         %-EPROTO if the property is not an array of strings,
 430  *         %-EOVERFLOW if the size of the property is not as expected,
 431  *         %-ENXIO if no suitable firmware interface is present.
 432  */
 433 int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
 434                                       const char *propname, const char **val,
 435                                       size_t nval)
 436 {
 437         if (is_of_node(fwnode))
 438                 return val ?
 439                         of_property_read_string_array(to_of_node(fwnode),
 440                                                       propname, val, nval) :
 441                         of_property_count_strings(to_of_node(fwnode), propname);
 442         else if (is_acpi_node(fwnode))
 443                 return acpi_dev_prop_read(to_acpi_node(fwnode), propname,
 444                                           DEV_PROP_STRING, val, nval);
 445         else if (is_pset(fwnode))
 446                 return pset_prop_read_array(to_pset(fwnode), propname,
 447                                             DEV_PROP_STRING, val, nval);
 448         return -ENXIO;
 449 }
 450 EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
 451
 452 /**
 453  * fwnode_property_read_string - return a string property of a firmware node
 454  * @fwnode: Firmware node to get the property of
 455  * @propname: Name of the property
 456  * @val: The value is stored here
 457  *
 458  * Read property @propname from the given firmware node and store the value into
 459  * @val if found.  The value is checked to be a string.
 460  *
 461  * Return: %0 if the property was found (success),
 462  *         %-EINVAL if given arguments are not valid,
 463  *         %-ENODATA if the property does not have a value,
 464  *         %-EPROTO or %-EILSEQ if the property is not a string,
 465  *         %-ENXIO if no suitable firmware interface is present.
 466  */
 467 int fwnode_property_read_string(struct fwnode_handle *fwnode,
 468                                 const char *propname, const char **val)
 469 {
 470         if (is_of_node(fwnode))
 471                 return of_property_read_string(to_of_node(fwnode), propname, val);
 472         else if (is_acpi_node(fwnode))
 473                 return acpi_dev_prop_read(to_acpi_node(fwnode), propname,
 474                                           DEV_PROP_STRING, val, 1);
 475
 476         return pset_prop_read_array(to_pset(fwnode), propname,
 477                                     DEV_PROP_STRING, val, 1);
 478 }
 479 EXPORT_SYMBOL_GPL(fwnode_property_read_string);
 480
 481 /**
 482  * device_get_next_child_node - Return the next child node handle for a device
 483  * @dev: Device to find the next child node for.
 484  * @child: Handle to one of the device's child nodes or a null handle.
 485  */
 486 struct fwnode_handle *device_get_next_child_node(struct device *dev,
 487                                                  struct fwnode_handle *child)
 488 {
 489         if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
 490                 struct device_node *node;
 491
 492                 node = of_get_next_available_child(dev->of_node, to_of_node(child));
 493                 if (node)
 494                         return &node->fwnode;
 495         } else if (IS_ENABLED(CONFIG_ACPI)) {
 496                 struct acpi_device *node;
 497
 498                 node = acpi_get_next_child(dev, to_acpi_node(child));
 499                 if (node)
 500                         return acpi_fwnode_handle(node);
 501         }
 502         return NULL;
 503 }
 504 EXPORT_SYMBOL_GPL(device_get_next_child_node);
 505
 506 /**
 507  * fwnode_handle_put - Drop reference to a device node
 508  * @fwnode: Pointer to the device node to drop the reference to.
 509  *
 510  * This has to be used when terminating device_for_each_child_node() iteration
 511  * with break or return to prevent stale device node references from being left
 512  * behind.
 513  */
 514 void fwnode_handle_put(struct fwnode_handle *fwnode)
 515 {
 516         if (is_of_node(fwnode))
 517                 of_node_put(to_of_node(fwnode));
 518 }
 519 EXPORT_SYMBOL_GPL(fwnode_handle_put);
 520
 521 /**
 522  * device_get_child_node_count - return the number of child nodes for device
 523  * @dev: Device to cound the child nodes for
 524  */
 525 unsigned int device_get_child_node_count(struct device *dev)
 526 {
 527         struct fwnode_handle *child;
 528         unsigned int count = 0;
 529
 530         device_for_each_child_node(dev, child)
 531                 count++;
 532
 533         return count;
 534 }
 535 EXPORT_SYMBOL_GPL(device_get_child_node_count);
 536
 537 bool device_dma_is_coherent(struct device *dev)
 538 {
 539         bool coherent = false;
 540
 541         if (IS_ENABLED(CONFIG_OF) && dev->of_node)
 542                 coherent = of_dma_is_coherent(dev->of_node);
 543         else
 544                 acpi_check_dma(ACPI_COMPANION(dev), &coherent);
 545
 546         return coherent;
 547 }
 548 EXPORT_SYMBOL_GPL(device_dma_is_coherent);
 549
 550 /**
 551  * device_get_phy_mode - Get phy mode for given device
 552  * @dev:        Pointer to the given device
 553  *
 554  * The function gets phy interface string from property 'phy-mode' or
 555  * 'phy-connection-type', and return its index in phy_modes table, or errno in
 556  * error case.
 557  */
 558 int device_get_phy_mode(struct device *dev)
 559 {
 560         const char *pm;
 561         int err, i;
 562
 563         err = device_property_read_string(dev, "phy-mode", &pm);
 564         if (err < 0)
 565                 err = device_property_read_string(dev,
 566                                                   "phy-connection-type", &pm);
 567         if (err < 0)
 568                 return err;
 569
 570         for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++)
 571                 if (!strcasecmp(pm, phy_modes(i)))
 572                         return i;
 573
 574         return -ENODEV;
 575 }
 576 EXPORT_SYMBOL_GPL(device_get_phy_mode);
 577
 578 static void *device_get_mac_addr(struct device *dev,
 579                                  const char *name, char *addr,
 580                                  int alen)
 581 {
 582         int ret = device_property_read_u8_array(dev, name, addr, alen);
 583
 584         if (ret == 0 && alen == ETH_ALEN && is_valid_ether_addr(addr))
 585                 return addr;
 586         return NULL;
 587 }
 588
 589 /**
 590  * device_get_mac_address - Get the MAC for a given device
 591  * @dev:        Pointer to the device
 592  * @addr:       Address of buffer to store the MAC in
 593  * @alen:       Length of the buffer pointed to by addr, should be ETH_ALEN
 594  *
 595  * Search the firmware node for the best MAC address to use.  'mac-address' is
 596  * checked first, because that is supposed to contain to "most recent" MAC
 597  * address. If that isn't set, then 'local-mac-address' is checked next,
 598  * because that is the default address.  If that isn't set, then the obsolete
 599  * 'address' is checked, just in case we're using an old device tree.
 600  *
 601  * Note that the 'address' property is supposed to contain a virtual address of
 602  * the register set, but some DTS files have redefined that property to be the
 603  * MAC address.
 604  *
 605  * All-zero MAC addresses are rejected, because those could be properties that
 606  * exist in the firmware tables, but were not updated by the firmware.  For
 607  * example, the DTS could define 'mac-address' and 'local-mac-address', with
 608  * zero MAC addresses.  Some older U-Boots only initialized 'local-mac-address'.
 609  * In this case, the real MAC is in 'local-mac-address', and 'mac-address'
 610  * exists but is all zeros.
 611 */
 612 void *device_get_mac_address(struct device *dev, char *addr, int alen)
 613 {
 614         char *res;
 615
 616         res = device_get_mac_addr(dev, "mac-address", addr, alen);
 617         if (res)
 618                 return res;
 619
 620         res = device_get_mac_addr(dev, "local-mac-address", addr, alen);
 621         if (res)
 622                 return res;
 623
 624         return device_get_mac_addr(dev, "address", addr, alen);
 625 }
 626 EXPORT_SYMBOL(device_get_mac_address);