nVMX x86: Check VPID value on vmentry of L2 guests
[linux/fpc-iii.git] / drivers / base / property.c
blob240ab5230ff6bad521c6d9d1ce99c5d6cbc6ca53
1 // SPDX-License-Identifier: GPL-2.0
2 /*
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>
8 */
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>
21 struct property_set {
22 struct device *dev;
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) \
35 ({ \
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) : \
41 NULL; \
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)
50 return NULL;
52 for (prop = pset->properties; prop->name; prop++)
53 if (!strcmp(name, prop->name))
54 return prop;
56 return NULL;
59 static const void *property_get_pointer(const struct property_entry *prop)
61 switch (prop->type) {
62 case DEV_PROP_U8:
63 if (prop->is_array)
64 return prop->pointer.u8_data;
65 return &prop->value.u8_data;
66 case DEV_PROP_U16:
67 if (prop->is_array)
68 return prop->pointer.u16_data;
69 return &prop->value.u16_data;
70 case DEV_PROP_U32:
71 if (prop->is_array)
72 return prop->pointer.u32_data;
73 return &prop->value.u32_data;
74 case DEV_PROP_U64:
75 if (prop->is_array)
76 return prop->pointer.u64_data;
77 return &prop->value.u64_data;
78 case DEV_PROP_STRING:
79 if (prop->is_array)
80 return prop->pointer.str;
81 return &prop->value.str;
82 default:
83 return NULL;
87 static void property_set_pointer(struct property_entry *prop, const void *pointer)
89 switch (prop->type) {
90 case DEV_PROP_U8:
91 if (prop->is_array)
92 prop->pointer.u8_data = pointer;
93 else
94 prop->value.u8_data = *((u8 *)pointer);
95 break;
96 case DEV_PROP_U16:
97 if (prop->is_array)
98 prop->pointer.u16_data = pointer;
99 else
100 prop->value.u16_data = *((u16 *)pointer);
101 break;
102 case DEV_PROP_U32:
103 if (prop->is_array)
104 prop->pointer.u32_data = pointer;
105 else
106 prop->value.u32_data = *((u32 *)pointer);
107 break;
108 case DEV_PROP_U64:
109 if (prop->is_array)
110 prop->pointer.u64_data = pointer;
111 else
112 prop->value.u64_data = *((u64 *)pointer);
113 break;
114 case DEV_PROP_STRING:
115 if (prop->is_array)
116 prop->pointer.str = pointer;
117 else
118 prop->value.str = pointer;
119 break;
120 default:
121 break;
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;
129 const void *pointer;
131 prop = pset_prop_get(pset, propname);
132 if (!prop)
133 return ERR_PTR(-EINVAL);
134 pointer = property_get_pointer(prop);
135 if (!pointer)
136 return ERR_PTR(-ENODATA);
137 if (length > prop->length)
138 return ERR_PTR(-EOVERFLOW);
139 return pointer;
142 static int pset_prop_read_u8_array(const struct property_set *pset,
143 const char *propname,
144 u8 *values, size_t nval)
146 const void *pointer;
147 size_t length = nval * sizeof(*values);
149 pointer = pset_prop_find(pset, propname, length);
150 if (IS_ERR(pointer))
151 return PTR_ERR(pointer);
153 memcpy(values, pointer, length);
154 return 0;
157 static int pset_prop_read_u16_array(const struct property_set *pset,
158 const char *propname,
159 u16 *values, size_t nval)
161 const void *pointer;
162 size_t length = nval * sizeof(*values);
164 pointer = pset_prop_find(pset, propname, length);
165 if (IS_ERR(pointer))
166 return PTR_ERR(pointer);
168 memcpy(values, pointer, length);
169 return 0;
172 static int pset_prop_read_u32_array(const struct property_set *pset,
173 const char *propname,
174 u32 *values, size_t nval)
176 const void *pointer;
177 size_t length = nval * sizeof(*values);
179 pointer = pset_prop_find(pset, propname, length);
180 if (IS_ERR(pointer))
181 return PTR_ERR(pointer);
183 memcpy(values, pointer, length);
184 return 0;
187 static int pset_prop_read_u64_array(const struct property_set *pset,
188 const char *propname,
189 u64 *values, size_t nval)
191 const void *pointer;
192 size_t length = nval * sizeof(*values);
194 pointer = pset_prop_find(pset, propname, length);
195 if (IS_ERR(pointer))
196 return PTR_ERR(pointer);
198 memcpy(values, pointer, length);
199 return 0;
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);
208 if (!prop)
209 return -EINVAL;
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;
219 const void *pointer;
220 size_t array_len, length;
222 /* Find out the array length. */
223 prop = pset_prop_get(pset, propname);
224 if (!prop)
225 return -EINVAL;
227 if (!prop->is_array)
228 /* The array length for a non-array string property is 1. */
229 array_len = 1;
230 else
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. */
236 if (!strings)
237 return array_len;
239 array_len = min(nval, array_len);
240 length = array_len * sizeof(*strings);
242 pointer = pset_prop_find(pset, propname, length);
243 if (IS_ERR(pointer))
244 return PTR_ERR(pointer);
246 memcpy(strings, pointer, length);
248 return array_len;
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,
267 size_t nval)
269 const struct property_set *node = to_pset_node(fwnode);
271 if (!val)
272 return pset_prop_count_elems_of_size(node, propname, elem_size);
274 switch (elem_size) {
275 case sizeof(u8):
276 return pset_prop_read_u8_array(node, propname, val, nval);
277 case sizeof(u16):
278 return pset_prop_read_u16_array(node, propname, val, nval);
279 case sizeof(u32):
280 return pset_prop_read_u32_array(node, propname, val, nval);
281 case sizeof(u64):
282 return pset_prop_read_u64_array(node, propname, val, nval);
285 return -ENXIO;
288 static int
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,
294 val, nval);
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)
324 bool ret;
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,
330 propname);
331 return ret;
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,
476 const char **val)
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
489 * index back.
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,
498 const char *string)
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,
507 size_t nval)
509 int ret;
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);
519 return ret;
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
530 * @val if found.
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),
544 val, nval);
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
556 * @val if found.
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),
570 val, nval);
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
582 * @val if found.
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),
596 val, nval);
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
608 * @val if found.
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),
622 val, nval);
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,
646 size_t nval)
648 int ret;
650 ret = fwnode_call_int_op(fwnode, property_read_string_array, propname,
651 val, nval);
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,
656 val, nval);
657 return ret;
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
692 * index back.
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)
703 const char **values;
704 int nval, ret;
706 nval = fwnode_property_read_string_array(fwnode, propname, NULL, 0);
707 if (nval < 0)
708 return nval;
710 if (nval == 0)
711 return -ENODATA;
713 values = kcalloc(nval, sizeof(*values), GFP_KERNEL);
714 if (!values)
715 return -ENOMEM;
717 ret = fwnode_property_read_string_array(fwnode, propname, values, nval);
718 if (ret < 0)
719 goto out;
721 ret = match_string(values, nval, string);
722 if (ret < 0)
723 ret = -ENODATA;
724 out:
725 kfree(values);
726 return ret;
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
742 * integer arguments.
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,
758 nargs, index, args);
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);
765 size_t i, nval;
767 if (p->is_array) {
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]);
773 kfree(pointer);
774 } else if (p->type == DEV_PROP_STRING) {
775 kfree(p->value.str);
777 kfree(p->name);
780 static int property_copy_string_array(struct property_entry *dst,
781 const struct property_entry *src)
783 const char **d;
784 size_t nval = src->length / sizeof(*d);
785 int i;
787 d = kcalloc(nval, sizeof(*d), GFP_KERNEL);
788 if (!d)
789 return -ENOMEM;
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]) {
794 while (--i >= 0)
795 kfree(d[i]);
796 kfree(d);
797 return -ENOMEM;
801 dst->pointer.str = d;
802 return 0;
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);
809 const void *new;
810 int error;
812 if (src->is_array) {
813 if (!src->length)
814 return -ENODATA;
816 if (src->type == DEV_PROP_STRING) {
817 error = property_copy_string_array(dst, src);
818 if (error)
819 return error;
820 new = dst->pointer.str;
821 } else {
822 new = kmemdup(pointer, src->length, GFP_KERNEL);
823 if (!new)
824 return -ENOMEM;
826 } else if (src->type == DEV_PROP_STRING) {
827 new = kstrdup(src->value.str, GFP_KERNEL);
828 if (!new && src->value.str)
829 return -ENOMEM;
830 } else {
831 new = pointer;
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);
841 if (!dst->name)
842 goto out_free_data;
844 return 0;
846 out_free_data:
847 property_entry_free_data(dst);
848 return -ENOMEM;
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;
862 int i, n = 0;
864 while (properties[n].name)
865 n++;
867 p = kcalloc(n + 1, sizeof(*p), GFP_KERNEL);
868 if (!p)
869 return ERR_PTR(-ENOMEM);
871 for (i = 0; i < n; i++) {
872 int ret = property_entry_copy_data(&p[i], &properties[i]);
873 if (ret) {
874 while (--i >= 0)
875 property_entry_free_data(&p[i]);
876 kfree(p);
877 return ERR_PTR(ret);
881 return p;
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);
899 kfree(properties);
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)
912 if (!pset)
913 return;
915 property_entries_free(pset->properties);
916 kfree(pset);
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);
935 if (!p)
936 return ERR_PTR(-ENOMEM);
938 properties = property_entries_dup(pset->properties);
939 if (IS_ERR(properties)) {
940 kfree(p);
941 return ERR_CAST(properties);
944 p->properties = properties;
945 return p;
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);
962 if (!fwnode)
963 return;
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);
970 if (pset) {
971 set_primary_fwnode(dev, NULL);
972 } else {
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)
978 pset_free_set(pset);
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
989 * @properties.
991 int device_add_properties(struct device *dev,
992 const struct property_entry *properties)
994 struct property_set *p, pset;
996 if (!properties)
997 return -EINVAL;
999 pset.properties = properties;
1001 p = pset_copy_set(&pset);
1002 if (IS_ERR(p))
1003 return PTR_ERR(p);
1005 p->fwnode.ops = &pset_fwnode_ops;
1006 set_secondary_fwnode(dev, &p->fwnode);
1007 p->dev = dev;
1008 return 0;
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
1018 * node's parents.
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);
1029 return parent;
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;
1071 if (!fwnode)
1072 return NULL;
1074 do {
1075 next_child = fwnode_get_next_child_node(fwnode, next_child);
1077 if (!next_child || fwnode_device_is_available(next_child))
1078 break;
1079 } while (next_child);
1081 return 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;
1096 if (dev->of_node)
1097 fwnode = &dev->of_node->fwnode;
1098 else if (adev)
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))
1139 return fwnode;
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
1151 * behind.
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)
1179 count++;
1181 return count;
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)
1192 return true;
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;
1205 else
1206 attr = DEV_DMA_NON_COHERENT;
1207 } else
1208 attr = acpi_get_dma_attr(ACPI_COMPANION(dev));
1210 return attr;
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
1220 * error case.
1222 int fwnode_get_phy_mode(struct fwnode_handle *fwnode)
1224 const char *pm;
1225 int err, i;
1227 err = fwnode_property_read_string(fwnode, "phy-mode", &pm);
1228 if (err < 0)
1229 err = fwnode_property_read_string(fwnode,
1230 "phy-connection-type", &pm);
1231 if (err < 0)
1232 return err;
1234 for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++)
1235 if (!strcasecmp(pm, phy_modes(i)))
1236 return i;
1238 return -ENODEV;
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
1248 * error case.
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,
1258 int alen)
1260 int ret = fwnode_property_read_u8_array(fwnode, name, addr, alen);
1262 if (ret == 0 && alen == ETH_ALEN && is_valid_ether_addr(addr))
1263 return addr;
1264 return NULL;
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
1281 * MAC address.
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)
1292 char *res;
1294 res = fwnode_get_mac_addr(fwnode, "mac-address", addr, alen);
1295 if (res)
1296 return res;
1298 res = fwnode_get_mac_addr(fwnode, "local-mac-address", addr, alen);
1299 if (res)
1300 return res;
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;
1330 int ret;
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);
1336 if (ret)
1337 return ret;
1339 return res.start;
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
1349 * are available.
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);
1375 return parent;
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);
1395 return parent;
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,
1436 u32 endpoint_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;
1443 int ret;
1445 ret = fwnode_graph_parse_endpoint(endpoint, &fwnode_ep);
1446 if (ret < 0)
1447 continue;
1449 if (fwnode_ep.port != port_id || fwnode_ep.id != endpoint_id)
1450 continue;
1452 remote = fwnode_graph_get_remote_port_parent(endpoint);
1453 if (!remote)
1454 return NULL;
1456 return fwnode_device_is_available(remote) ? remote : NULL;
1459 return 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
1470 * @fwnode.
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);