1 // SPDX-License-Identifier: GPL-2.0
3 * property.c - Unified device property interface.
5 * Copyright (C) 2014, Intel Corporation
6 * Authors: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
7 * Mika Westerberg <mika.westerberg@linux.intel.com>
10 #include <linux/acpi.h>
11 #include <linux/export.h>
12 #include <linux/kernel.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>
23 struct fwnode_handle fwnode
;
24 const struct property_entry
*properties
;
27 static const struct fwnode_operations pset_fwnode_ops
;
29 static inline bool is_pset_node(const struct fwnode_handle
*fwnode
)
31 return !IS_ERR_OR_NULL(fwnode
) && fwnode
->ops
== &pset_fwnode_ops
;
34 #define to_pset_node(__fwnode) \
36 typeof(__fwnode) __to_pset_node_fwnode = __fwnode; \
38 is_pset_node(__to_pset_node_fwnode) ? \
39 container_of(__to_pset_node_fwnode, \
40 struct property_set, fwnode) : \
44 static const struct property_entry
*
45 pset_prop_get(const struct property_set
*pset
, const char *name
)
47 const struct property_entry
*prop
;
49 if (!pset
|| !pset
->properties
)
52 for (prop
= pset
->properties
; prop
->name
; prop
++)
53 if (!strcmp(name
, prop
->name
))
59 static const void *property_get_pointer(const struct property_entry
*prop
)
64 return prop
->pointer
.u8_data
;
65 return &prop
->value
.u8_data
;
68 return prop
->pointer
.u16_data
;
69 return &prop
->value
.u16_data
;
72 return prop
->pointer
.u32_data
;
73 return &prop
->value
.u32_data
;
76 return prop
->pointer
.u64_data
;
77 return &prop
->value
.u64_data
;
80 return prop
->pointer
.str
;
81 return &prop
->value
.str
;
87 static void property_set_pointer(struct property_entry
*prop
, const void *pointer
)
92 prop
->pointer
.u8_data
= pointer
;
94 prop
->value
.u8_data
= *((u8
*)pointer
);
98 prop
->pointer
.u16_data
= pointer
;
100 prop
->value
.u16_data
= *((u16
*)pointer
);
104 prop
->pointer
.u32_data
= pointer
;
106 prop
->value
.u32_data
= *((u32
*)pointer
);
110 prop
->pointer
.u64_data
= pointer
;
112 prop
->value
.u64_data
= *((u64
*)pointer
);
114 case DEV_PROP_STRING
:
116 prop
->pointer
.str
= pointer
;
118 prop
->value
.str
= pointer
;
125 static const void *pset_prop_find(const struct property_set
*pset
,
126 const char *propname
, size_t length
)
128 const struct property_entry
*prop
;
131 prop
= pset_prop_get(pset
, propname
);
133 return ERR_PTR(-EINVAL
);
134 pointer
= property_get_pointer(prop
);
136 return ERR_PTR(-ENODATA
);
137 if (length
> prop
->length
)
138 return ERR_PTR(-EOVERFLOW
);
142 static int pset_prop_read_u8_array(const struct property_set
*pset
,
143 const char *propname
,
144 u8
*values
, size_t nval
)
147 size_t length
= nval
* sizeof(*values
);
149 pointer
= pset_prop_find(pset
, propname
, length
);
151 return PTR_ERR(pointer
);
153 memcpy(values
, pointer
, length
);
157 static int pset_prop_read_u16_array(const struct property_set
*pset
,
158 const char *propname
,
159 u16
*values
, size_t nval
)
162 size_t length
= nval
* sizeof(*values
);
164 pointer
= pset_prop_find(pset
, propname
, length
);
166 return PTR_ERR(pointer
);
168 memcpy(values
, pointer
, length
);
172 static int pset_prop_read_u32_array(const struct property_set
*pset
,
173 const char *propname
,
174 u32
*values
, size_t nval
)
177 size_t length
= nval
* sizeof(*values
);
179 pointer
= pset_prop_find(pset
, propname
, length
);
181 return PTR_ERR(pointer
);
183 memcpy(values
, pointer
, length
);
187 static int pset_prop_read_u64_array(const struct property_set
*pset
,
188 const char *propname
,
189 u64
*values
, size_t nval
)
192 size_t length
= nval
* sizeof(*values
);
194 pointer
= pset_prop_find(pset
, propname
, length
);
196 return PTR_ERR(pointer
);
198 memcpy(values
, pointer
, length
);
202 static int pset_prop_count_elems_of_size(const struct property_set
*pset
,
203 const char *propname
, size_t length
)
205 const struct property_entry
*prop
;
207 prop
= pset_prop_get(pset
, propname
);
211 return prop
->length
/ length
;
214 static int pset_prop_read_string_array(const struct property_set
*pset
,
215 const char *propname
,
216 const char **strings
, size_t nval
)
218 const struct property_entry
*prop
;
220 size_t array_len
, length
;
222 /* Find out the array length. */
223 prop
= pset_prop_get(pset
, propname
);
228 /* The array length for a non-array string property is 1. */
231 /* Find the length of an array. */
232 array_len
= pset_prop_count_elems_of_size(pset
, propname
,
233 sizeof(const char *));
235 /* Return how many there are if strings is NULL. */
239 array_len
= min(nval
, array_len
);
240 length
= array_len
* sizeof(*strings
);
242 pointer
= pset_prop_find(pset
, propname
, length
);
244 return PTR_ERR(pointer
);
246 memcpy(strings
, pointer
, length
);
251 struct fwnode_handle
*dev_fwnode(struct device
*dev
)
253 return IS_ENABLED(CONFIG_OF
) && dev
->of_node
?
254 &dev
->of_node
->fwnode
: dev
->fwnode
;
256 EXPORT_SYMBOL_GPL(dev_fwnode
);
258 static bool pset_fwnode_property_present(const struct fwnode_handle
*fwnode
,
259 const char *propname
)
261 return !!pset_prop_get(to_pset_node(fwnode
), propname
);
264 static int pset_fwnode_read_int_array(const struct fwnode_handle
*fwnode
,
265 const char *propname
,
266 unsigned int elem_size
, void *val
,
269 const struct property_set
*node
= to_pset_node(fwnode
);
272 return pset_prop_count_elems_of_size(node
, propname
, elem_size
);
276 return pset_prop_read_u8_array(node
, propname
, val
, nval
);
278 return pset_prop_read_u16_array(node
, propname
, val
, nval
);
280 return pset_prop_read_u32_array(node
, propname
, val
, nval
);
282 return pset_prop_read_u64_array(node
, propname
, val
, nval
);
289 pset_fwnode_property_read_string_array(const struct fwnode_handle
*fwnode
,
290 const char *propname
,
291 const char **val
, size_t nval
)
293 return pset_prop_read_string_array(to_pset_node(fwnode
), propname
,
297 static const struct fwnode_operations pset_fwnode_ops
= {
298 .property_present
= pset_fwnode_property_present
,
299 .property_read_int_array
= pset_fwnode_read_int_array
,
300 .property_read_string_array
= pset_fwnode_property_read_string_array
,
304 * device_property_present - check if a property of a device is present
305 * @dev: Device whose property is being checked
306 * @propname: Name of the property
308 * Check if property @propname is present in the device firmware description.
310 bool device_property_present(struct device
*dev
, const char *propname
)
312 return fwnode_property_present(dev_fwnode(dev
), propname
);
314 EXPORT_SYMBOL_GPL(device_property_present
);
317 * fwnode_property_present - check if a property of a firmware node is present
318 * @fwnode: Firmware node whose property to check
319 * @propname: Name of the property
321 bool fwnode_property_present(const struct fwnode_handle
*fwnode
,
322 const char *propname
)
326 ret
= fwnode_call_bool_op(fwnode
, property_present
, propname
);
327 if (ret
== false && !IS_ERR_OR_NULL(fwnode
) &&
328 !IS_ERR_OR_NULL(fwnode
->secondary
))
329 ret
= fwnode_call_bool_op(fwnode
->secondary
, property_present
,
333 EXPORT_SYMBOL_GPL(fwnode_property_present
);
336 * device_property_read_u8_array - return a u8 array property of a device
337 * @dev: Device to get the property of
338 * @propname: Name of the property
339 * @val: The values are stored here or %NULL to return the number of values
340 * @nval: Size of the @val array
342 * Function reads an array of u8 properties with @propname from the device
343 * firmware description and stores them to @val if found.
345 * Return: number of values if @val was %NULL,
346 * %0 if the property was found (success),
347 * %-EINVAL if given arguments are not valid,
348 * %-ENODATA if the property does not have a value,
349 * %-EPROTO if the property is not an array of numbers,
350 * %-EOVERFLOW if the size of the property is not as expected.
351 * %-ENXIO if no suitable firmware interface is present.
353 int device_property_read_u8_array(struct device
*dev
, const char *propname
,
354 u8
*val
, size_t nval
)
356 return fwnode_property_read_u8_array(dev_fwnode(dev
), propname
, val
, nval
);
358 EXPORT_SYMBOL_GPL(device_property_read_u8_array
);
361 * device_property_read_u16_array - return a u16 array property of a device
362 * @dev: Device to get the property of
363 * @propname: Name of the property
364 * @val: The values are stored here or %NULL to return the number of values
365 * @nval: Size of the @val array
367 * Function reads an array of u16 properties with @propname from the device
368 * firmware description and stores them to @val if found.
370 * Return: number of values if @val was %NULL,
371 * %0 if the property was found (success),
372 * %-EINVAL if given arguments are not valid,
373 * %-ENODATA if the property does not have a value,
374 * %-EPROTO if the property is not an array of numbers,
375 * %-EOVERFLOW if the size of the property is not as expected.
376 * %-ENXIO if no suitable firmware interface is present.
378 int device_property_read_u16_array(struct device
*dev
, const char *propname
,
379 u16
*val
, size_t nval
)
381 return fwnode_property_read_u16_array(dev_fwnode(dev
), propname
, val
, nval
);
383 EXPORT_SYMBOL_GPL(device_property_read_u16_array
);
386 * device_property_read_u32_array - return a u32 array property of a device
387 * @dev: Device to get the property of
388 * @propname: Name of the property
389 * @val: The values are stored here or %NULL to return the number of values
390 * @nval: Size of the @val array
392 * Function reads an array of u32 properties with @propname from the device
393 * firmware description and stores them to @val if found.
395 * Return: number of values if @val was %NULL,
396 * %0 if the property was found (success),
397 * %-EINVAL if given arguments are not valid,
398 * %-ENODATA if the property does not have a value,
399 * %-EPROTO if the property is not an array of numbers,
400 * %-EOVERFLOW if the size of the property is not as expected.
401 * %-ENXIO if no suitable firmware interface is present.
403 int device_property_read_u32_array(struct device
*dev
, const char *propname
,
404 u32
*val
, size_t nval
)
406 return fwnode_property_read_u32_array(dev_fwnode(dev
), propname
, val
, nval
);
408 EXPORT_SYMBOL_GPL(device_property_read_u32_array
);
411 * device_property_read_u64_array - return a u64 array property of a device
412 * @dev: Device to get the property of
413 * @propname: Name of the property
414 * @val: The values are stored here or %NULL to return the number of values
415 * @nval: Size of the @val array
417 * Function reads an array of u64 properties with @propname from the device
418 * firmware description and stores them to @val if found.
420 * Return: number of values if @val was %NULL,
421 * %0 if the property was found (success),
422 * %-EINVAL if given arguments are not valid,
423 * %-ENODATA if the property does not have a value,
424 * %-EPROTO if the property is not an array of numbers,
425 * %-EOVERFLOW if the size of the property is not as expected.
426 * %-ENXIO if no suitable firmware interface is present.
428 int device_property_read_u64_array(struct device
*dev
, const char *propname
,
429 u64
*val
, size_t nval
)
431 return fwnode_property_read_u64_array(dev_fwnode(dev
), propname
, val
, nval
);
433 EXPORT_SYMBOL_GPL(device_property_read_u64_array
);
436 * device_property_read_string_array - return a string array property of device
437 * @dev: Device to get the property of
438 * @propname: Name of the property
439 * @val: The values are stored here or %NULL to return the number of values
440 * @nval: Size of the @val array
442 * Function reads an array of string properties with @propname from the device
443 * firmware description and stores them to @val if found.
445 * Return: number of values read on success if @val is non-NULL,
446 * number of values available on success if @val is NULL,
447 * %-EINVAL if given arguments are not valid,
448 * %-ENODATA if the property does not have a value,
449 * %-EPROTO or %-EILSEQ if the property is not an array of strings,
450 * %-EOVERFLOW if the size of the property is not as expected.
451 * %-ENXIO if no suitable firmware interface is present.
453 int device_property_read_string_array(struct device
*dev
, const char *propname
,
454 const char **val
, size_t nval
)
456 return fwnode_property_read_string_array(dev_fwnode(dev
), propname
, val
, nval
);
458 EXPORT_SYMBOL_GPL(device_property_read_string_array
);
461 * device_property_read_string - return a string property of a device
462 * @dev: Device to get the property of
463 * @propname: Name of the property
464 * @val: The value is stored here
466 * Function reads property @propname from the device firmware description and
467 * stores the value into @val if found. The value is checked to be a string.
469 * Return: %0 if the property was found (success),
470 * %-EINVAL if given arguments are not valid,
471 * %-ENODATA if the property does not have a value,
472 * %-EPROTO or %-EILSEQ if the property type is not a string.
473 * %-ENXIO if no suitable firmware interface is present.
475 int device_property_read_string(struct device
*dev
, const char *propname
,
478 return fwnode_property_read_string(dev_fwnode(dev
), propname
, val
);
480 EXPORT_SYMBOL_GPL(device_property_read_string
);
483 * device_property_match_string - find a string in an array and return index
484 * @dev: Device to get the property of
485 * @propname: Name of the property holding the array
486 * @string: String to look for
488 * Find a given string in a string array and if it is found return the
491 * Return: %0 if the property was found (success),
492 * %-EINVAL if given arguments are not valid,
493 * %-ENODATA if the property does not have a value,
494 * %-EPROTO if the property is not an array of strings,
495 * %-ENXIO if no suitable firmware interface is present.
497 int device_property_match_string(struct device
*dev
, const char *propname
,
500 return fwnode_property_match_string(dev_fwnode(dev
), propname
, string
);
502 EXPORT_SYMBOL_GPL(device_property_match_string
);
504 static int fwnode_property_read_int_array(const struct fwnode_handle
*fwnode
,
505 const char *propname
,
506 unsigned int elem_size
, void *val
,
511 ret
= fwnode_call_int_op(fwnode
, property_read_int_array
, propname
,
512 elem_size
, val
, nval
);
513 if (ret
== -EINVAL
&& !IS_ERR_OR_NULL(fwnode
) &&
514 !IS_ERR_OR_NULL(fwnode
->secondary
))
515 ret
= fwnode_call_int_op(
516 fwnode
->secondary
, property_read_int_array
, propname
,
517 elem_size
, val
, nval
);
523 * fwnode_property_read_u8_array - return a u8 array property of firmware node
524 * @fwnode: Firmware node to get the property of
525 * @propname: Name of the property
526 * @val: The values are stored here or %NULL to return the number of values
527 * @nval: Size of the @val array
529 * Read an array of u8 properties with @propname from @fwnode and stores them to
532 * Return: number of values if @val was %NULL,
533 * %0 if the property was found (success),
534 * %-EINVAL if given arguments are not valid,
535 * %-ENODATA if the property does not have a value,
536 * %-EPROTO if the property is not an array of numbers,
537 * %-EOVERFLOW if the size of the property is not as expected,
538 * %-ENXIO if no suitable firmware interface is present.
540 int fwnode_property_read_u8_array(const struct fwnode_handle
*fwnode
,
541 const char *propname
, u8
*val
, size_t nval
)
543 return fwnode_property_read_int_array(fwnode
, propname
, sizeof(u8
),
546 EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array
);
549 * fwnode_property_read_u16_array - return a u16 array property of firmware node
550 * @fwnode: Firmware node to get the property of
551 * @propname: Name of the property
552 * @val: The values are stored here or %NULL to return the number of values
553 * @nval: Size of the @val array
555 * Read an array of u16 properties with @propname from @fwnode and store them to
558 * Return: number of values if @val was %NULL,
559 * %0 if the property was found (success),
560 * %-EINVAL if given arguments are not valid,
561 * %-ENODATA if the property does not have a value,
562 * %-EPROTO if the property is not an array of numbers,
563 * %-EOVERFLOW if the size of the property is not as expected,
564 * %-ENXIO if no suitable firmware interface is present.
566 int fwnode_property_read_u16_array(const struct fwnode_handle
*fwnode
,
567 const char *propname
, u16
*val
, size_t nval
)
569 return fwnode_property_read_int_array(fwnode
, propname
, sizeof(u16
),
572 EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array
);
575 * fwnode_property_read_u32_array - return a u32 array property of firmware node
576 * @fwnode: Firmware node to get the property of
577 * @propname: Name of the property
578 * @val: The values are stored here or %NULL to return the number of values
579 * @nval: Size of the @val array
581 * Read an array of u32 properties with @propname from @fwnode store them to
584 * Return: number of values if @val was %NULL,
585 * %0 if the property was found (success),
586 * %-EINVAL if given arguments are not valid,
587 * %-ENODATA if the property does not have a value,
588 * %-EPROTO if the property is not an array of numbers,
589 * %-EOVERFLOW if the size of the property is not as expected,
590 * %-ENXIO if no suitable firmware interface is present.
592 int fwnode_property_read_u32_array(const struct fwnode_handle
*fwnode
,
593 const char *propname
, u32
*val
, size_t nval
)
595 return fwnode_property_read_int_array(fwnode
, propname
, sizeof(u32
),
598 EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array
);
601 * fwnode_property_read_u64_array - return a u64 array property firmware node
602 * @fwnode: Firmware node to get the property of
603 * @propname: Name of the property
604 * @val: The values are stored here or %NULL to return the number of values
605 * @nval: Size of the @val array
607 * Read an array of u64 properties with @propname from @fwnode and store them to
610 * Return: number of values if @val was %NULL,
611 * %0 if the property was found (success),
612 * %-EINVAL if given arguments are not valid,
613 * %-ENODATA if the property does not have a value,
614 * %-EPROTO if the property is not an array of numbers,
615 * %-EOVERFLOW if the size of the property is not as expected,
616 * %-ENXIO if no suitable firmware interface is present.
618 int fwnode_property_read_u64_array(const struct fwnode_handle
*fwnode
,
619 const char *propname
, u64
*val
, size_t nval
)
621 return fwnode_property_read_int_array(fwnode
, propname
, sizeof(u64
),
624 EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array
);
627 * fwnode_property_read_string_array - return string array property of a node
628 * @fwnode: Firmware node to get the property of
629 * @propname: Name of the property
630 * @val: The values are stored here or %NULL to return the number of values
631 * @nval: Size of the @val array
633 * Read an string list property @propname from the given firmware node and store
634 * them to @val if found.
636 * Return: number of values read on success if @val is non-NULL,
637 * number of values available on success if @val is NULL,
638 * %-EINVAL if given arguments are not valid,
639 * %-ENODATA if the property does not have a value,
640 * %-EPROTO or %-EILSEQ if the property is not an array of strings,
641 * %-EOVERFLOW if the size of the property is not as expected,
642 * %-ENXIO if no suitable firmware interface is present.
644 int fwnode_property_read_string_array(const struct fwnode_handle
*fwnode
,
645 const char *propname
, const char **val
,
650 ret
= fwnode_call_int_op(fwnode
, property_read_string_array
, propname
,
652 if (ret
== -EINVAL
&& !IS_ERR_OR_NULL(fwnode
) &&
653 !IS_ERR_OR_NULL(fwnode
->secondary
))
654 ret
= fwnode_call_int_op(fwnode
->secondary
,
655 property_read_string_array
, propname
,
659 EXPORT_SYMBOL_GPL(fwnode_property_read_string_array
);
662 * fwnode_property_read_string - return a string property of a firmware node
663 * @fwnode: Firmware node to get the property of
664 * @propname: Name of the property
665 * @val: The value is stored here
667 * Read property @propname from the given firmware node and store the value into
668 * @val if found. The value is checked to be a string.
670 * Return: %0 if the property was found (success),
671 * %-EINVAL if given arguments are not valid,
672 * %-ENODATA if the property does not have a value,
673 * %-EPROTO or %-EILSEQ if the property is not a string,
674 * %-ENXIO if no suitable firmware interface is present.
676 int fwnode_property_read_string(const struct fwnode_handle
*fwnode
,
677 const char *propname
, const char **val
)
679 int ret
= fwnode_property_read_string_array(fwnode
, propname
, val
, 1);
681 return ret
< 0 ? ret
: 0;
683 EXPORT_SYMBOL_GPL(fwnode_property_read_string
);
686 * fwnode_property_match_string - find a string in an array and return index
687 * @fwnode: Firmware node to get the property of
688 * @propname: Name of the property holding the array
689 * @string: String to look for
691 * Find a given string in a string array and if it is found return the
694 * Return: %0 if the property was found (success),
695 * %-EINVAL if given arguments are not valid,
696 * %-ENODATA if the property does not have a value,
697 * %-EPROTO if the property is not an array of strings,
698 * %-ENXIO if no suitable firmware interface is present.
700 int fwnode_property_match_string(const struct fwnode_handle
*fwnode
,
701 const char *propname
, const char *string
)
706 nval
= fwnode_property_read_string_array(fwnode
, propname
, NULL
, 0);
713 values
= kcalloc(nval
, sizeof(*values
), GFP_KERNEL
);
717 ret
= fwnode_property_read_string_array(fwnode
, propname
, values
, nval
);
721 ret
= match_string(values
, nval
, string
);
728 EXPORT_SYMBOL_GPL(fwnode_property_match_string
);
731 * fwnode_property_get_reference_args() - Find a reference with arguments
732 * @fwnode: Firmware node where to look for the reference
733 * @prop: The name of the property
734 * @nargs_prop: The name of the property telling the number of
735 * arguments in the referred node. NULL if @nargs is known,
736 * otherwise @nargs is ignored. Only relevant on OF.
737 * @nargs: Number of arguments. Ignored if @nargs_prop is non-NULL.
738 * @index: Index of the reference, from zero onwards.
739 * @args: Result structure with reference and integer arguments.
741 * Obtain a reference based on a named property in an fwnode, with
744 * Caller is responsible to call fwnode_handle_put() on the returned
745 * args->fwnode pointer.
747 * Returns: %0 on success
748 * %-ENOENT when the index is out of bounds, the index has an empty
749 * reference or the property was not found
750 * %-EINVAL on parse error
752 int fwnode_property_get_reference_args(const struct fwnode_handle
*fwnode
,
753 const char *prop
, const char *nargs_prop
,
754 unsigned int nargs
, unsigned int index
,
755 struct fwnode_reference_args
*args
)
757 return fwnode_call_int_op(fwnode
, get_reference_args
, prop
, nargs_prop
,
760 EXPORT_SYMBOL_GPL(fwnode_property_get_reference_args
);
762 static void property_entry_free_data(const struct property_entry
*p
)
764 const void *pointer
= property_get_pointer(p
);
768 if (p
->type
== DEV_PROP_STRING
&& p
->pointer
.str
) {
769 nval
= p
->length
/ sizeof(const char *);
770 for (i
= 0; i
< nval
; i
++)
771 kfree(p
->pointer
.str
[i
]);
774 } else if (p
->type
== DEV_PROP_STRING
) {
780 static int property_copy_string_array(struct property_entry
*dst
,
781 const struct property_entry
*src
)
784 size_t nval
= src
->length
/ sizeof(*d
);
787 d
= kcalloc(nval
, sizeof(*d
), GFP_KERNEL
);
791 for (i
= 0; i
< nval
; i
++) {
792 d
[i
] = kstrdup(src
->pointer
.str
[i
], GFP_KERNEL
);
793 if (!d
[i
] && src
->pointer
.str
[i
]) {
801 dst
->pointer
.str
= d
;
805 static int property_entry_copy_data(struct property_entry
*dst
,
806 const struct property_entry
*src
)
808 const void *pointer
= property_get_pointer(src
);
816 if (src
->type
== DEV_PROP_STRING
) {
817 error
= property_copy_string_array(dst
, src
);
820 new = dst
->pointer
.str
;
822 new = kmemdup(pointer
, src
->length
, GFP_KERNEL
);
826 } else if (src
->type
== DEV_PROP_STRING
) {
827 new = kstrdup(src
->value
.str
, GFP_KERNEL
);
828 if (!new && src
->value
.str
)
834 dst
->length
= src
->length
;
835 dst
->is_array
= src
->is_array
;
836 dst
->type
= src
->type
;
838 property_set_pointer(dst
, new);
840 dst
->name
= kstrdup(src
->name
, GFP_KERNEL
);
847 property_entry_free_data(dst
);
852 * property_entries_dup - duplicate array of properties
853 * @properties: array of properties to copy
855 * This function creates a deep copy of the given NULL-terminated array
856 * of property entries.
858 struct property_entry
*
859 property_entries_dup(const struct property_entry
*properties
)
861 struct property_entry
*p
;
864 while (properties
[n
].name
)
867 p
= kcalloc(n
+ 1, sizeof(*p
), GFP_KERNEL
);
869 return ERR_PTR(-ENOMEM
);
871 for (i
= 0; i
< n
; i
++) {
872 int ret
= property_entry_copy_data(&p
[i
], &properties
[i
]);
875 property_entry_free_data(&p
[i
]);
883 EXPORT_SYMBOL_GPL(property_entries_dup
);
886 * property_entries_free - free previously allocated array of properties
887 * @properties: array of properties to destroy
889 * This function frees given NULL-terminated array of property entries,
890 * along with their data.
892 void property_entries_free(const struct property_entry
*properties
)
894 const struct property_entry
*p
;
896 for (p
= properties
; p
->name
; p
++)
897 property_entry_free_data(p
);
901 EXPORT_SYMBOL_GPL(property_entries_free
);
904 * pset_free_set - releases memory allocated for copied property set
905 * @pset: Property set to release
907 * Function takes previously copied property set and releases all the
908 * memory allocated to it.
910 static void pset_free_set(struct property_set
*pset
)
915 property_entries_free(pset
->properties
);
920 * pset_copy_set - copies property set
921 * @pset: Property set to copy
923 * This function takes a deep copy of the given property set and returns
924 * pointer to the copy. Call device_free_property_set() to free resources
925 * allocated in this function.
927 * Return: Pointer to the new property set or error pointer.
929 static struct property_set
*pset_copy_set(const struct property_set
*pset
)
931 struct property_entry
*properties
;
932 struct property_set
*p
;
934 p
= kzalloc(sizeof(*p
), GFP_KERNEL
);
936 return ERR_PTR(-ENOMEM
);
938 properties
= property_entries_dup(pset
->properties
);
939 if (IS_ERR(properties
)) {
941 return ERR_CAST(properties
);
944 p
->properties
= properties
;
949 * device_remove_properties - Remove properties from a device object.
950 * @dev: Device whose properties to remove.
952 * The function removes properties previously associated to the device
953 * secondary firmware node with device_add_properties(). Memory allocated
954 * to the properties will also be released.
956 void device_remove_properties(struct device
*dev
)
958 struct fwnode_handle
*fwnode
;
959 struct property_set
*pset
;
961 fwnode
= dev_fwnode(dev
);
965 * Pick either primary or secondary node depending which one holds
966 * the pset. If there is no real firmware node (ACPI/DT) primary
967 * will hold the pset.
969 pset
= to_pset_node(fwnode
);
971 set_primary_fwnode(dev
, NULL
);
973 pset
= to_pset_node(fwnode
->secondary
);
974 if (pset
&& dev
== pset
->dev
)
975 set_secondary_fwnode(dev
, NULL
);
977 if (pset
&& dev
== pset
->dev
)
980 EXPORT_SYMBOL_GPL(device_remove_properties
);
983 * device_add_properties - Add a collection of properties to a device object.
984 * @dev: Device to add properties to.
985 * @properties: Collection of properties to add.
987 * Associate a collection of device properties represented by @properties with
988 * @dev as its secondary firmware node. The function takes a copy of
991 int device_add_properties(struct device
*dev
,
992 const struct property_entry
*properties
)
994 struct property_set
*p
, pset
;
999 pset
.properties
= properties
;
1001 p
= pset_copy_set(&pset
);
1005 p
->fwnode
.ops
= &pset_fwnode_ops
;
1006 set_secondary_fwnode(dev
, &p
->fwnode
);
1010 EXPORT_SYMBOL_GPL(device_add_properties
);
1013 * fwnode_get_next_parent - Iterate to the node's parent
1014 * @fwnode: Firmware whose parent is retrieved
1016 * This is like fwnode_get_parent() except that it drops the refcount
1017 * on the passed node, making it suitable for iterating through a
1020 * Returns a node pointer with refcount incremented, use
1021 * fwnode_handle_node() on it when done.
1023 struct fwnode_handle
*fwnode_get_next_parent(struct fwnode_handle
*fwnode
)
1025 struct fwnode_handle
*parent
= fwnode_get_parent(fwnode
);
1027 fwnode_handle_put(fwnode
);
1031 EXPORT_SYMBOL_GPL(fwnode_get_next_parent
);
1034 * fwnode_get_parent - Return parent firwmare node
1035 * @fwnode: Firmware whose parent is retrieved
1037 * Return parent firmware node of the given node if possible or %NULL if no
1038 * parent was available.
1040 struct fwnode_handle
*fwnode_get_parent(const struct fwnode_handle
*fwnode
)
1042 return fwnode_call_ptr_op(fwnode
, get_parent
);
1044 EXPORT_SYMBOL_GPL(fwnode_get_parent
);
1047 * fwnode_get_next_child_node - Return the next child node handle for a node
1048 * @fwnode: Firmware node to find the next child node for.
1049 * @child: Handle to one of the node's child nodes or a %NULL handle.
1051 struct fwnode_handle
*
1052 fwnode_get_next_child_node(const struct fwnode_handle
*fwnode
,
1053 struct fwnode_handle
*child
)
1055 return fwnode_call_ptr_op(fwnode
, get_next_child_node
, child
);
1057 EXPORT_SYMBOL_GPL(fwnode_get_next_child_node
);
1060 * fwnode_get_next_available_child_node - Return the next
1061 * available child node handle for a node
1062 * @fwnode: Firmware node to find the next child node for.
1063 * @child: Handle to one of the node's child nodes or a %NULL handle.
1065 struct fwnode_handle
*
1066 fwnode_get_next_available_child_node(const struct fwnode_handle
*fwnode
,
1067 struct fwnode_handle
*child
)
1069 struct fwnode_handle
*next_child
= child
;
1075 next_child
= fwnode_get_next_child_node(fwnode
, next_child
);
1077 if (!next_child
|| fwnode_device_is_available(next_child
))
1079 } while (next_child
);
1083 EXPORT_SYMBOL_GPL(fwnode_get_next_available_child_node
);
1086 * device_get_next_child_node - Return the next child node handle for a device
1087 * @dev: Device to find the next child node for.
1088 * @child: Handle to one of the device's child nodes or a null handle.
1090 struct fwnode_handle
*device_get_next_child_node(struct device
*dev
,
1091 struct fwnode_handle
*child
)
1093 struct acpi_device
*adev
= ACPI_COMPANION(dev
);
1094 struct fwnode_handle
*fwnode
= NULL
;
1097 fwnode
= &dev
->of_node
->fwnode
;
1099 fwnode
= acpi_fwnode_handle(adev
);
1101 return fwnode_get_next_child_node(fwnode
, child
);
1103 EXPORT_SYMBOL_GPL(device_get_next_child_node
);
1106 * fwnode_get_named_child_node - Return first matching named child node handle
1107 * @fwnode: Firmware node to find the named child node for.
1108 * @childname: String to match child node name against.
1110 struct fwnode_handle
*
1111 fwnode_get_named_child_node(const struct fwnode_handle
*fwnode
,
1112 const char *childname
)
1114 return fwnode_call_ptr_op(fwnode
, get_named_child_node
, childname
);
1116 EXPORT_SYMBOL_GPL(fwnode_get_named_child_node
);
1119 * device_get_named_child_node - Return first matching named child node handle
1120 * @dev: Device to find the named child node for.
1121 * @childname: String to match child node name against.
1123 struct fwnode_handle
*device_get_named_child_node(struct device
*dev
,
1124 const char *childname
)
1126 return fwnode_get_named_child_node(dev_fwnode(dev
), childname
);
1128 EXPORT_SYMBOL_GPL(device_get_named_child_node
);
1131 * fwnode_handle_get - Obtain a reference to a device node
1132 * @fwnode: Pointer to the device node to obtain the reference to.
1134 * Returns the fwnode handle.
1136 struct fwnode_handle
*fwnode_handle_get(struct fwnode_handle
*fwnode
)
1138 if (!fwnode_has_op(fwnode
, get
))
1141 return fwnode_call_ptr_op(fwnode
, get
);
1143 EXPORT_SYMBOL_GPL(fwnode_handle_get
);
1146 * fwnode_handle_put - Drop reference to a device node
1147 * @fwnode: Pointer to the device node to drop the reference to.
1149 * This has to be used when terminating device_for_each_child_node() iteration
1150 * with break or return to prevent stale device node references from being left
1153 void fwnode_handle_put(struct fwnode_handle
*fwnode
)
1155 fwnode_call_void_op(fwnode
, put
);
1157 EXPORT_SYMBOL_GPL(fwnode_handle_put
);
1160 * fwnode_device_is_available - check if a device is available for use
1161 * @fwnode: Pointer to the fwnode of the device.
1163 bool fwnode_device_is_available(const struct fwnode_handle
*fwnode
)
1165 return fwnode_call_bool_op(fwnode
, device_is_available
);
1167 EXPORT_SYMBOL_GPL(fwnode_device_is_available
);
1170 * device_get_child_node_count - return the number of child nodes for device
1171 * @dev: Device to cound the child nodes for
1173 unsigned int device_get_child_node_count(struct device
*dev
)
1175 struct fwnode_handle
*child
;
1176 unsigned int count
= 0;
1178 device_for_each_child_node(dev
, child
)
1183 EXPORT_SYMBOL_GPL(device_get_child_node_count
);
1185 bool device_dma_supported(struct device
*dev
)
1187 /* For DT, this is always supported.
1188 * For ACPI, this depends on CCA, which
1189 * is determined by the acpi_dma_supported().
1191 if (IS_ENABLED(CONFIG_OF
) && dev
->of_node
)
1194 return acpi_dma_supported(ACPI_COMPANION(dev
));
1196 EXPORT_SYMBOL_GPL(device_dma_supported
);
1198 enum dev_dma_attr
device_get_dma_attr(struct device
*dev
)
1200 enum dev_dma_attr attr
= DEV_DMA_NOT_SUPPORTED
;
1202 if (IS_ENABLED(CONFIG_OF
) && dev
->of_node
) {
1203 if (of_dma_is_coherent(dev
->of_node
))
1204 attr
= DEV_DMA_COHERENT
;
1206 attr
= DEV_DMA_NON_COHERENT
;
1208 attr
= acpi_get_dma_attr(ACPI_COMPANION(dev
));
1212 EXPORT_SYMBOL_GPL(device_get_dma_attr
);
1215 * fwnode_get_phy_mode - Get phy mode for given firmware node
1216 * @fwnode: Pointer to the given node
1218 * The function gets phy interface string from property 'phy-mode' or
1219 * 'phy-connection-type', and return its index in phy_modes table, or errno in
1222 int fwnode_get_phy_mode(struct fwnode_handle
*fwnode
)
1227 err
= fwnode_property_read_string(fwnode
, "phy-mode", &pm
);
1229 err
= fwnode_property_read_string(fwnode
,
1230 "phy-connection-type", &pm
);
1234 for (i
= 0; i
< PHY_INTERFACE_MODE_MAX
; i
++)
1235 if (!strcasecmp(pm
, phy_modes(i
)))
1240 EXPORT_SYMBOL_GPL(fwnode_get_phy_mode
);
1243 * device_get_phy_mode - Get phy mode for given device
1244 * @dev: Pointer to the given device
1246 * The function gets phy interface string from property 'phy-mode' or
1247 * 'phy-connection-type', and return its index in phy_modes table, or errno in
1250 int device_get_phy_mode(struct device
*dev
)
1252 return fwnode_get_phy_mode(dev_fwnode(dev
));
1254 EXPORT_SYMBOL_GPL(device_get_phy_mode
);
1256 static void *fwnode_get_mac_addr(struct fwnode_handle
*fwnode
,
1257 const char *name
, char *addr
,
1260 int ret
= fwnode_property_read_u8_array(fwnode
, name
, addr
, alen
);
1262 if (ret
== 0 && alen
== ETH_ALEN
&& is_valid_ether_addr(addr
))
1268 * fwnode_get_mac_address - Get the MAC from the firmware node
1269 * @fwnode: Pointer to the firmware node
1270 * @addr: Address of buffer to store the MAC in
1271 * @alen: Length of the buffer pointed to by addr, should be ETH_ALEN
1273 * Search the firmware node for the best MAC address to use. 'mac-address' is
1274 * checked first, because that is supposed to contain to "most recent" MAC
1275 * address. If that isn't set, then 'local-mac-address' is checked next,
1276 * because that is the default address. If that isn't set, then the obsolete
1277 * 'address' is checked, just in case we're using an old device tree.
1279 * Note that the 'address' property is supposed to contain a virtual address of
1280 * the register set, but some DTS files have redefined that property to be the
1283 * All-zero MAC addresses are rejected, because those could be properties that
1284 * exist in the firmware tables, but were not updated by the firmware. For
1285 * example, the DTS could define 'mac-address' and 'local-mac-address', with
1286 * zero MAC addresses. Some older U-Boots only initialized 'local-mac-address'.
1287 * In this case, the real MAC is in 'local-mac-address', and 'mac-address'
1288 * exists but is all zeros.
1290 void *fwnode_get_mac_address(struct fwnode_handle
*fwnode
, char *addr
, int alen
)
1294 res
= fwnode_get_mac_addr(fwnode
, "mac-address", addr
, alen
);
1298 res
= fwnode_get_mac_addr(fwnode
, "local-mac-address", addr
, alen
);
1302 return fwnode_get_mac_addr(fwnode
, "address", addr
, alen
);
1304 EXPORT_SYMBOL(fwnode_get_mac_address
);
1307 * device_get_mac_address - Get the MAC for a given device
1308 * @dev: Pointer to the device
1309 * @addr: Address of buffer to store the MAC in
1310 * @alen: Length of the buffer pointed to by addr, should be ETH_ALEN
1312 void *device_get_mac_address(struct device
*dev
, char *addr
, int alen
)
1314 return fwnode_get_mac_address(dev_fwnode(dev
), addr
, alen
);
1316 EXPORT_SYMBOL(device_get_mac_address
);
1319 * fwnode_irq_get - Get IRQ directly from a fwnode
1320 * @fwnode: Pointer to the firmware node
1321 * @index: Zero-based index of the IRQ
1323 * Returns Linux IRQ number on success. Other values are determined
1324 * accordingly to acpi_/of_ irq_get() operation.
1326 int fwnode_irq_get(struct fwnode_handle
*fwnode
, unsigned int index
)
1328 struct device_node
*of_node
= to_of_node(fwnode
);
1329 struct resource res
;
1332 if (IS_ENABLED(CONFIG_OF
) && of_node
)
1333 return of_irq_get(of_node
, index
);
1335 ret
= acpi_irq_get(ACPI_HANDLE_FWNODE(fwnode
), index
, &res
);
1341 EXPORT_SYMBOL(fwnode_irq_get
);
1344 * device_graph_get_next_endpoint - Get next endpoint firmware node
1345 * @fwnode: Pointer to the parent firmware node
1346 * @prev: Previous endpoint node or %NULL to get the first
1348 * Returns an endpoint firmware node pointer or %NULL if no more endpoints
1351 struct fwnode_handle
*
1352 fwnode_graph_get_next_endpoint(const struct fwnode_handle
*fwnode
,
1353 struct fwnode_handle
*prev
)
1355 return fwnode_call_ptr_op(fwnode
, graph_get_next_endpoint
, prev
);
1357 EXPORT_SYMBOL_GPL(fwnode_graph_get_next_endpoint
);
1360 * fwnode_graph_get_port_parent - Return the device fwnode of a port endpoint
1361 * @endpoint: Endpoint firmware node of the port
1363 * Return: the firmware node of the device the @endpoint belongs to.
1365 struct fwnode_handle
*
1366 fwnode_graph_get_port_parent(const struct fwnode_handle
*endpoint
)
1368 struct fwnode_handle
*port
, *parent
;
1370 port
= fwnode_get_parent(endpoint
);
1371 parent
= fwnode_call_ptr_op(port
, graph_get_port_parent
);
1373 fwnode_handle_put(port
);
1377 EXPORT_SYMBOL_GPL(fwnode_graph_get_port_parent
);
1380 * fwnode_graph_get_remote_port_parent - Return fwnode of a remote device
1381 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1383 * Extracts firmware node of a remote device the @fwnode points to.
1385 struct fwnode_handle
*
1386 fwnode_graph_get_remote_port_parent(const struct fwnode_handle
*fwnode
)
1388 struct fwnode_handle
*endpoint
, *parent
;
1390 endpoint
= fwnode_graph_get_remote_endpoint(fwnode
);
1391 parent
= fwnode_graph_get_port_parent(endpoint
);
1393 fwnode_handle_put(endpoint
);
1397 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port_parent
);
1400 * fwnode_graph_get_remote_port - Return fwnode of a remote port
1401 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1403 * Extracts firmware node of a remote port the @fwnode points to.
1405 struct fwnode_handle
*
1406 fwnode_graph_get_remote_port(const struct fwnode_handle
*fwnode
)
1408 return fwnode_get_next_parent(fwnode_graph_get_remote_endpoint(fwnode
));
1410 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_port
);
1413 * fwnode_graph_get_remote_endpoint - Return fwnode of a remote endpoint
1414 * @fwnode: Endpoint firmware node pointing to the remote endpoint
1416 * Extracts firmware node of a remote endpoint the @fwnode points to.
1418 struct fwnode_handle
*
1419 fwnode_graph_get_remote_endpoint(const struct fwnode_handle
*fwnode
)
1421 return fwnode_call_ptr_op(fwnode
, graph_get_remote_endpoint
);
1423 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_endpoint
);
1426 * fwnode_graph_get_remote_node - get remote parent node for given port/endpoint
1427 * @fwnode: pointer to parent fwnode_handle containing graph port/endpoint
1428 * @port_id: identifier of the parent port node
1429 * @endpoint_id: identifier of the endpoint node
1431 * Return: Remote fwnode handle associated with remote endpoint node linked
1432 * to @node. Use fwnode_node_put() on it when done.
1434 struct fwnode_handle
*
1435 fwnode_graph_get_remote_node(const struct fwnode_handle
*fwnode
, u32 port_id
,
1438 struct fwnode_handle
*endpoint
= NULL
;
1440 while ((endpoint
= fwnode_graph_get_next_endpoint(fwnode
, endpoint
))) {
1441 struct fwnode_endpoint fwnode_ep
;
1442 struct fwnode_handle
*remote
;
1445 ret
= fwnode_graph_parse_endpoint(endpoint
, &fwnode_ep
);
1449 if (fwnode_ep
.port
!= port_id
|| fwnode_ep
.id
!= endpoint_id
)
1452 remote
= fwnode_graph_get_remote_port_parent(endpoint
);
1456 return fwnode_device_is_available(remote
) ? remote
: NULL
;
1461 EXPORT_SYMBOL_GPL(fwnode_graph_get_remote_node
);
1464 * fwnode_graph_parse_endpoint - parse common endpoint node properties
1465 * @fwnode: pointer to endpoint fwnode_handle
1466 * @endpoint: pointer to the fwnode endpoint data structure
1468 * Parse @fwnode representing a graph endpoint node and store the
1469 * information in @endpoint. The caller must hold a reference to
1472 int fwnode_graph_parse_endpoint(const struct fwnode_handle
*fwnode
,
1473 struct fwnode_endpoint
*endpoint
)
1475 memset(endpoint
, 0, sizeof(*endpoint
));
1477 return fwnode_call_int_op(fwnode
, graph_parse_endpoint
, endpoint
);
1479 EXPORT_SYMBOL(fwnode_graph_parse_endpoint
);
1481 const void *device_get_match_data(struct device
*dev
)
1483 return fwnode_call_ptr_op(dev_fwnode(dev
), device_get_match_data
, dev
);
1485 EXPORT_SYMBOL_GPL(device_get_match_data
);