Loading...
Note: File does not exist in v3.1.
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
22struct property_set {
23 struct fwnode_handle fwnode;
24 struct property_entry *properties;
25};
26
27static inline bool is_pset_node(struct fwnode_handle *fwnode)
28{
29 return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_PDATA;
30}
31
32static inline struct property_set *to_pset_node(struct fwnode_handle *fwnode)
33{
34 return is_pset_node(fwnode) ?
35 container_of(fwnode, struct property_set, fwnode) : NULL;
36}
37
38static struct property_entry *pset_prop_get(struct property_set *pset,
39 const char *name)
40{
41 struct property_entry *prop;
42
43 if (!pset || !pset->properties)
44 return NULL;
45
46 for (prop = pset->properties; prop->name; prop++)
47 if (!strcmp(name, prop->name))
48 return prop;
49
50 return NULL;
51}
52
53static void *pset_prop_find(struct property_set *pset, const char *propname,
54 size_t length)
55{
56 struct property_entry *prop;
57 void *pointer;
58
59 prop = pset_prop_get(pset, propname);
60 if (!prop)
61 return ERR_PTR(-EINVAL);
62 if (prop->is_array)
63 pointer = prop->pointer.raw_data;
64 else
65 pointer = &prop->value.raw_data;
66 if (!pointer)
67 return ERR_PTR(-ENODATA);
68 if (length > prop->length)
69 return ERR_PTR(-EOVERFLOW);
70 return pointer;
71}
72
73static int pset_prop_read_u8_array(struct property_set *pset,
74 const char *propname,
75 u8 *values, size_t nval)
76{
77 void *pointer;
78 size_t length = nval * sizeof(*values);
79
80 pointer = pset_prop_find(pset, propname, length);
81 if (IS_ERR(pointer))
82 return PTR_ERR(pointer);
83
84 memcpy(values, pointer, length);
85 return 0;
86}
87
88static int pset_prop_read_u16_array(struct property_set *pset,
89 const char *propname,
90 u16 *values, size_t nval)
91{
92 void *pointer;
93 size_t length = nval * sizeof(*values);
94
95 pointer = pset_prop_find(pset, propname, length);
96 if (IS_ERR(pointer))
97 return PTR_ERR(pointer);
98
99 memcpy(values, pointer, length);
100 return 0;
101}
102
103static int pset_prop_read_u32_array(struct property_set *pset,
104 const char *propname,
105 u32 *values, size_t nval)
106{
107 void *pointer;
108 size_t length = nval * sizeof(*values);
109
110 pointer = pset_prop_find(pset, propname, length);
111 if (IS_ERR(pointer))
112 return PTR_ERR(pointer);
113
114 memcpy(values, pointer, length);
115 return 0;
116}
117
118static int pset_prop_read_u64_array(struct property_set *pset,
119 const char *propname,
120 u64 *values, size_t nval)
121{
122 void *pointer;
123 size_t length = nval * sizeof(*values);
124
125 pointer = pset_prop_find(pset, propname, length);
126 if (IS_ERR(pointer))
127 return PTR_ERR(pointer);
128
129 memcpy(values, pointer, length);
130 return 0;
131}
132
133static int pset_prop_count_elems_of_size(struct property_set *pset,
134 const char *propname, size_t length)
135{
136 struct property_entry *prop;
137
138 prop = pset_prop_get(pset, propname);
139 if (!prop)
140 return -EINVAL;
141
142 return prop->length / length;
143}
144
145static int pset_prop_read_string_array(struct property_set *pset,
146 const char *propname,
147 const char **strings, size_t nval)
148{
149 void *pointer;
150 size_t length = nval * sizeof(*strings);
151
152 pointer = pset_prop_find(pset, propname, length);
153 if (IS_ERR(pointer))
154 return PTR_ERR(pointer);
155
156 memcpy(strings, pointer, length);
157 return 0;
158}
159
160static int pset_prop_read_string(struct property_set *pset,
161 const char *propname, const char **strings)
162{
163 struct property_entry *prop;
164 const char **pointer;
165
166 prop = pset_prop_get(pset, propname);
167 if (!prop)
168 return -EINVAL;
169 if (!prop->is_string)
170 return -EILSEQ;
171 if (prop->is_array) {
172 pointer = prop->pointer.str;
173 if (!pointer)
174 return -ENODATA;
175 } else {
176 pointer = &prop->value.str;
177 if (*pointer && strnlen(*pointer, prop->length) >= prop->length)
178 return -EILSEQ;
179 }
180
181 *strings = *pointer;
182 return 0;
183}
184
185static inline struct fwnode_handle *dev_fwnode(struct device *dev)
186{
187 return IS_ENABLED(CONFIG_OF) && dev->of_node ?
188 &dev->of_node->fwnode : dev->fwnode;
189}
190
191/**
192 * device_property_present - check if a property of a device is present
193 * @dev: Device whose property is being checked
194 * @propname: Name of the property
195 *
196 * Check if property @propname is present in the device firmware description.
197 */
198bool device_property_present(struct device *dev, const char *propname)
199{
200 return fwnode_property_present(dev_fwnode(dev), propname);
201}
202EXPORT_SYMBOL_GPL(device_property_present);
203
204static bool __fwnode_property_present(struct fwnode_handle *fwnode,
205 const char *propname)
206{
207 if (is_of_node(fwnode))
208 return of_property_read_bool(to_of_node(fwnode), propname);
209 else if (is_acpi_node(fwnode))
210 return !acpi_node_prop_get(fwnode, propname, NULL);
211 else if (is_pset_node(fwnode))
212 return !!pset_prop_get(to_pset_node(fwnode), propname);
213 return false;
214}
215
216/**
217 * fwnode_property_present - check if a property of a firmware node is present
218 * @fwnode: Firmware node whose property to check
219 * @propname: Name of the property
220 */
221bool fwnode_property_present(struct fwnode_handle *fwnode, const char *propname)
222{
223 bool ret;
224
225 ret = __fwnode_property_present(fwnode, propname);
226 if (ret == false && !IS_ERR_OR_NULL(fwnode) &&
227 !IS_ERR_OR_NULL(fwnode->secondary))
228 ret = __fwnode_property_present(fwnode->secondary, propname);
229 return ret;
230}
231EXPORT_SYMBOL_GPL(fwnode_property_present);
232
233/**
234 * device_property_read_u8_array - return a u8 array property of a device
235 * @dev: Device to get the property of
236 * @propname: Name of the property
237 * @val: The values are stored here or %NULL to return the number of values
238 * @nval: Size of the @val array
239 *
240 * Function reads an array of u8 properties with @propname from the device
241 * firmware description and stores them to @val if found.
242 *
243 * Return: number of values if @val was %NULL,
244 * %0 if the property was found (success),
245 * %-EINVAL if given arguments are not valid,
246 * %-ENODATA if the property does not have a value,
247 * %-EPROTO if the property is not an array of numbers,
248 * %-EOVERFLOW if the size of the property is not as expected.
249 * %-ENXIO if no suitable firmware interface is present.
250 */
251int device_property_read_u8_array(struct device *dev, const char *propname,
252 u8 *val, size_t nval)
253{
254 return fwnode_property_read_u8_array(dev_fwnode(dev), propname, val, nval);
255}
256EXPORT_SYMBOL_GPL(device_property_read_u8_array);
257
258/**
259 * device_property_read_u16_array - return a u16 array property of a device
260 * @dev: Device to get the property of
261 * @propname: Name of the property
262 * @val: The values are stored here or %NULL to return the number of values
263 * @nval: Size of the @val array
264 *
265 * Function reads an array of u16 properties with @propname from the device
266 * firmware description and stores them to @val if found.
267 *
268 * Return: number of values if @val was %NULL,
269 * %0 if the property was found (success),
270 * %-EINVAL if given arguments are not valid,
271 * %-ENODATA if the property does not have a value,
272 * %-EPROTO if the property is not an array of numbers,
273 * %-EOVERFLOW if the size of the property is not as expected.
274 * %-ENXIO if no suitable firmware interface is present.
275 */
276int device_property_read_u16_array(struct device *dev, const char *propname,
277 u16 *val, size_t nval)
278{
279 return fwnode_property_read_u16_array(dev_fwnode(dev), propname, val, nval);
280}
281EXPORT_SYMBOL_GPL(device_property_read_u16_array);
282
283/**
284 * device_property_read_u32_array - return a u32 array property of a device
285 * @dev: Device to get the property of
286 * @propname: Name of the property
287 * @val: The values are stored here or %NULL to return the number of values
288 * @nval: Size of the @val array
289 *
290 * Function reads an array of u32 properties with @propname from the device
291 * firmware description and stores them to @val if found.
292 *
293 * Return: number of values if @val was %NULL,
294 * %0 if the property was found (success),
295 * %-EINVAL if given arguments are not valid,
296 * %-ENODATA if the property does not have a value,
297 * %-EPROTO if the property is not an array of numbers,
298 * %-EOVERFLOW if the size of the property is not as expected.
299 * %-ENXIO if no suitable firmware interface is present.
300 */
301int device_property_read_u32_array(struct device *dev, const char *propname,
302 u32 *val, size_t nval)
303{
304 return fwnode_property_read_u32_array(dev_fwnode(dev), propname, val, nval);
305}
306EXPORT_SYMBOL_GPL(device_property_read_u32_array);
307
308/**
309 * device_property_read_u64_array - return a u64 array property of a device
310 * @dev: Device to get the property of
311 * @propname: Name of the property
312 * @val: The values are stored here or %NULL to return the number of values
313 * @nval: Size of the @val array
314 *
315 * Function reads an array of u64 properties with @propname from the device
316 * firmware description and stores them to @val if found.
317 *
318 * Return: number of values if @val was %NULL,
319 * %0 if the property was found (success),
320 * %-EINVAL if given arguments are not valid,
321 * %-ENODATA if the property does not have a value,
322 * %-EPROTO if the property is not an array of numbers,
323 * %-EOVERFLOW if the size of the property is not as expected.
324 * %-ENXIO if no suitable firmware interface is present.
325 */
326int device_property_read_u64_array(struct device *dev, const char *propname,
327 u64 *val, size_t nval)
328{
329 return fwnode_property_read_u64_array(dev_fwnode(dev), propname, val, nval);
330}
331EXPORT_SYMBOL_GPL(device_property_read_u64_array);
332
333/**
334 * device_property_read_string_array - return a string array property of device
335 * @dev: Device to get the property of
336 * @propname: Name of the property
337 * @val: The values are stored here or %NULL to return the number of values
338 * @nval: Size of the @val array
339 *
340 * Function reads an array of string properties with @propname from the device
341 * firmware description and stores them to @val if found.
342 *
343 * Return: number of values if @val was %NULL,
344 * %0 if the property was found (success),
345 * %-EINVAL if given arguments are not valid,
346 * %-ENODATA if the property does not have a value,
347 * %-EPROTO or %-EILSEQ if the property is not an array of strings,
348 * %-EOVERFLOW if the size of the property is not as expected.
349 * %-ENXIO if no suitable firmware interface is present.
350 */
351int device_property_read_string_array(struct device *dev, const char *propname,
352 const char **val, size_t nval)
353{
354 return fwnode_property_read_string_array(dev_fwnode(dev), propname, val, nval);
355}
356EXPORT_SYMBOL_GPL(device_property_read_string_array);
357
358/**
359 * device_property_read_string - return a string property of a device
360 * @dev: Device to get the property of
361 * @propname: Name of the property
362 * @val: The value is stored here
363 *
364 * Function reads property @propname from the device firmware description and
365 * stores the value into @val if found. The value is checked to be a string.
366 *
367 * Return: %0 if the property was found (success),
368 * %-EINVAL if given arguments are not valid,
369 * %-ENODATA if the property does not have a value,
370 * %-EPROTO or %-EILSEQ if the property type is not a string.
371 * %-ENXIO if no suitable firmware interface is present.
372 */
373int device_property_read_string(struct device *dev, const char *propname,
374 const char **val)
375{
376 return fwnode_property_read_string(dev_fwnode(dev), propname, val);
377}
378EXPORT_SYMBOL_GPL(device_property_read_string);
379
380/**
381 * device_property_match_string - find a string in an array and return index
382 * @dev: Device to get the property of
383 * @propname: Name of the property holding the array
384 * @string: String to look for
385 *
386 * Find a given string in a string array and if it is found return the
387 * index back.
388 *
389 * Return: %0 if the property was found (success),
390 * %-EINVAL if given arguments are not valid,
391 * %-ENODATA if the property does not have a value,
392 * %-EPROTO if the property is not an array of strings,
393 * %-ENXIO if no suitable firmware interface is present.
394 */
395int device_property_match_string(struct device *dev, const char *propname,
396 const char *string)
397{
398 return fwnode_property_match_string(dev_fwnode(dev), propname, string);
399}
400EXPORT_SYMBOL_GPL(device_property_match_string);
401
402#define OF_DEV_PROP_READ_ARRAY(node, propname, type, val, nval) \
403 (val) ? of_property_read_##type##_array((node), (propname), (val), (nval)) \
404 : of_property_count_elems_of_size((node), (propname), sizeof(type))
405
406#define PSET_PROP_READ_ARRAY(node, propname, type, val, nval) \
407 (val) ? pset_prop_read_##type##_array((node), (propname), (val), (nval)) \
408 : pset_prop_count_elems_of_size((node), (propname), sizeof(type))
409
410#define FWNODE_PROP_READ(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \
411({ \
412 int _ret_; \
413 if (is_of_node(_fwnode_)) \
414 _ret_ = OF_DEV_PROP_READ_ARRAY(to_of_node(_fwnode_), _propname_, \
415 _type_, _val_, _nval_); \
416 else if (is_acpi_node(_fwnode_)) \
417 _ret_ = acpi_node_prop_read(_fwnode_, _propname_, _proptype_, \
418 _val_, _nval_); \
419 else if (is_pset_node(_fwnode_)) \
420 _ret_ = PSET_PROP_READ_ARRAY(to_pset_node(_fwnode_), _propname_, \
421 _type_, _val_, _nval_); \
422 else \
423 _ret_ = -ENXIO; \
424 _ret_; \
425})
426
427#define FWNODE_PROP_READ_ARRAY(_fwnode_, _propname_, _type_, _proptype_, _val_, _nval_) \
428({ \
429 int _ret_; \
430 _ret_ = FWNODE_PROP_READ(_fwnode_, _propname_, _type_, _proptype_, \
431 _val_, _nval_); \
432 if (_ret_ == -EINVAL && !IS_ERR_OR_NULL(_fwnode_) && \
433 !IS_ERR_OR_NULL(_fwnode_->secondary)) \
434 _ret_ = FWNODE_PROP_READ(_fwnode_->secondary, _propname_, _type_, \
435 _proptype_, _val_, _nval_); \
436 _ret_; \
437})
438
439/**
440 * fwnode_property_read_u8_array - return a u8 array property of firmware node
441 * @fwnode: Firmware node to get the property of
442 * @propname: Name of the property
443 * @val: The values are stored here or %NULL to return the number of values
444 * @nval: Size of the @val array
445 *
446 * Read an array of u8 properties with @propname from @fwnode and stores them to
447 * @val if found.
448 *
449 * Return: number of values if @val was %NULL,
450 * %0 if the property was found (success),
451 * %-EINVAL if given arguments are not valid,
452 * %-ENODATA if the property does not have a value,
453 * %-EPROTO if the property is not an array of numbers,
454 * %-EOVERFLOW if the size of the property is not as expected,
455 * %-ENXIO if no suitable firmware interface is present.
456 */
457int fwnode_property_read_u8_array(struct fwnode_handle *fwnode,
458 const char *propname, u8 *val, size_t nval)
459{
460 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u8, DEV_PROP_U8,
461 val, nval);
462}
463EXPORT_SYMBOL_GPL(fwnode_property_read_u8_array);
464
465/**
466 * fwnode_property_read_u16_array - return a u16 array property of firmware node
467 * @fwnode: Firmware node to get the property of
468 * @propname: Name of the property
469 * @val: The values are stored here or %NULL to return the number of values
470 * @nval: Size of the @val array
471 *
472 * Read an array of u16 properties with @propname from @fwnode and store them to
473 * @val if found.
474 *
475 * Return: number of values if @val was %NULL,
476 * %0 if the property was found (success),
477 * %-EINVAL if given arguments are not valid,
478 * %-ENODATA if the property does not have a value,
479 * %-EPROTO if the property is not an array of numbers,
480 * %-EOVERFLOW if the size of the property is not as expected,
481 * %-ENXIO if no suitable firmware interface is present.
482 */
483int fwnode_property_read_u16_array(struct fwnode_handle *fwnode,
484 const char *propname, u16 *val, size_t nval)
485{
486 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u16, DEV_PROP_U16,
487 val, nval);
488}
489EXPORT_SYMBOL_GPL(fwnode_property_read_u16_array);
490
491/**
492 * fwnode_property_read_u32_array - return a u32 array property of firmware node
493 * @fwnode: Firmware node to get the property of
494 * @propname: Name of the property
495 * @val: The values are stored here or %NULL to return the number of values
496 * @nval: Size of the @val array
497 *
498 * Read an array of u32 properties with @propname from @fwnode store them to
499 * @val if found.
500 *
501 * Return: number of values if @val was %NULL,
502 * %0 if the property was found (success),
503 * %-EINVAL if given arguments are not valid,
504 * %-ENODATA if the property does not have a value,
505 * %-EPROTO if the property is not an array of numbers,
506 * %-EOVERFLOW if the size of the property is not as expected,
507 * %-ENXIO if no suitable firmware interface is present.
508 */
509int fwnode_property_read_u32_array(struct fwnode_handle *fwnode,
510 const char *propname, u32 *val, size_t nval)
511{
512 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u32, DEV_PROP_U32,
513 val, nval);
514}
515EXPORT_SYMBOL_GPL(fwnode_property_read_u32_array);
516
517/**
518 * fwnode_property_read_u64_array - return a u64 array property firmware node
519 * @fwnode: Firmware node to get the property of
520 * @propname: Name of the property
521 * @val: The values are stored here or %NULL to return the number of values
522 * @nval: Size of the @val array
523 *
524 * Read an array of u64 properties with @propname from @fwnode and store them to
525 * @val if found.
526 *
527 * Return: number of values if @val was %NULL,
528 * %0 if the property was found (success),
529 * %-EINVAL if given arguments are not valid,
530 * %-ENODATA if the property does not have a value,
531 * %-EPROTO if the property is not an array of numbers,
532 * %-EOVERFLOW if the size of the property is not as expected,
533 * %-ENXIO if no suitable firmware interface is present.
534 */
535int fwnode_property_read_u64_array(struct fwnode_handle *fwnode,
536 const char *propname, u64 *val, size_t nval)
537{
538 return FWNODE_PROP_READ_ARRAY(fwnode, propname, u64, DEV_PROP_U64,
539 val, nval);
540}
541EXPORT_SYMBOL_GPL(fwnode_property_read_u64_array);
542
543static int __fwnode_property_read_string_array(struct fwnode_handle *fwnode,
544 const char *propname,
545 const char **val, size_t nval)
546{
547 if (is_of_node(fwnode))
548 return val ?
549 of_property_read_string_array(to_of_node(fwnode),
550 propname, val, nval) :
551 of_property_count_strings(to_of_node(fwnode), propname);
552 else if (is_acpi_node(fwnode))
553 return acpi_node_prop_read(fwnode, propname, DEV_PROP_STRING,
554 val, nval);
555 else if (is_pset_node(fwnode))
556 return val ?
557 pset_prop_read_string_array(to_pset_node(fwnode),
558 propname, val, nval) :
559 pset_prop_count_elems_of_size(to_pset_node(fwnode),
560 propname,
561 sizeof(const char *));
562 return -ENXIO;
563}
564
565static int __fwnode_property_read_string(struct fwnode_handle *fwnode,
566 const char *propname, const char **val)
567{
568 if (is_of_node(fwnode))
569 return of_property_read_string(to_of_node(fwnode), propname, val);
570 else if (is_acpi_node(fwnode))
571 return acpi_node_prop_read(fwnode, propname, DEV_PROP_STRING,
572 val, 1);
573 else if (is_pset_node(fwnode))
574 return pset_prop_read_string(to_pset_node(fwnode), propname, val);
575 return -ENXIO;
576}
577
578/**
579 * fwnode_property_read_string_array - return string array property of a node
580 * @fwnode: Firmware node to get the property of
581 * @propname: Name of the property
582 * @val: The values are stored here or %NULL to return the number of values
583 * @nval: Size of the @val array
584 *
585 * Read an string list property @propname from the given firmware node and store
586 * them to @val if found.
587 *
588 * Return: number of values if @val was %NULL,
589 * %0 if the property was found (success),
590 * %-EINVAL if given arguments are not valid,
591 * %-ENODATA if the property does not have a value,
592 * %-EPROTO if the property is not an array of strings,
593 * %-EOVERFLOW if the size of the property is not as expected,
594 * %-ENXIO if no suitable firmware interface is present.
595 */
596int fwnode_property_read_string_array(struct fwnode_handle *fwnode,
597 const char *propname, const char **val,
598 size_t nval)
599{
600 int ret;
601
602 ret = __fwnode_property_read_string_array(fwnode, propname, val, nval);
603 if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&
604 !IS_ERR_OR_NULL(fwnode->secondary))
605 ret = __fwnode_property_read_string_array(fwnode->secondary,
606 propname, val, nval);
607 return ret;
608}
609EXPORT_SYMBOL_GPL(fwnode_property_read_string_array);
610
611/**
612 * fwnode_property_read_string - return a string property of a firmware node
613 * @fwnode: Firmware node to get the property of
614 * @propname: Name of the property
615 * @val: The value is stored here
616 *
617 * Read property @propname from the given firmware node and store the value into
618 * @val if found. The value is checked to be a string.
619 *
620 * Return: %0 if the property was found (success),
621 * %-EINVAL if given arguments are not valid,
622 * %-ENODATA if the property does not have a value,
623 * %-EPROTO or %-EILSEQ if the property is not a string,
624 * %-ENXIO if no suitable firmware interface is present.
625 */
626int fwnode_property_read_string(struct fwnode_handle *fwnode,
627 const char *propname, const char **val)
628{
629 int ret;
630
631 ret = __fwnode_property_read_string(fwnode, propname, val);
632 if (ret == -EINVAL && !IS_ERR_OR_NULL(fwnode) &&
633 !IS_ERR_OR_NULL(fwnode->secondary))
634 ret = __fwnode_property_read_string(fwnode->secondary,
635 propname, val);
636 return ret;
637}
638EXPORT_SYMBOL_GPL(fwnode_property_read_string);
639
640/**
641 * fwnode_property_match_string - find a string in an array and return index
642 * @fwnode: Firmware node to get the property of
643 * @propname: Name of the property holding the array
644 * @string: String to look for
645 *
646 * Find a given string in a string array and if it is found return the
647 * index back.
648 *
649 * Return: %0 if the property was found (success),
650 * %-EINVAL if given arguments are not valid,
651 * %-ENODATA if the property does not have a value,
652 * %-EPROTO if the property is not an array of strings,
653 * %-ENXIO if no suitable firmware interface is present.
654 */
655int fwnode_property_match_string(struct fwnode_handle *fwnode,
656 const char *propname, const char *string)
657{
658 const char **values;
659 int nval, ret;
660
661 nval = fwnode_property_read_string_array(fwnode, propname, NULL, 0);
662 if (nval < 0)
663 return nval;
664
665 if (nval == 0)
666 return -ENODATA;
667
668 values = kcalloc(nval, sizeof(*values), GFP_KERNEL);
669 if (!values)
670 return -ENOMEM;
671
672 ret = fwnode_property_read_string_array(fwnode, propname, values, nval);
673 if (ret < 0)
674 goto out;
675
676 ret = match_string(values, nval, string);
677 if (ret < 0)
678 ret = -ENODATA;
679out:
680 kfree(values);
681 return ret;
682}
683EXPORT_SYMBOL_GPL(fwnode_property_match_string);
684
685/**
686 * pset_free_set - releases memory allocated for copied property set
687 * @pset: Property set to release
688 *
689 * Function takes previously copied property set and releases all the
690 * memory allocated to it.
691 */
692static void pset_free_set(struct property_set *pset)
693{
694 const struct property_entry *prop;
695 size_t i, nval;
696
697 if (!pset)
698 return;
699
700 for (prop = pset->properties; prop->name; prop++) {
701 if (prop->is_array) {
702 if (prop->is_string && prop->pointer.str) {
703 nval = prop->length / sizeof(const char *);
704 for (i = 0; i < nval; i++)
705 kfree(prop->pointer.str[i]);
706 }
707 kfree(prop->pointer.raw_data);
708 } else if (prop->is_string) {
709 kfree(prop->value.str);
710 }
711 kfree(prop->name);
712 }
713
714 kfree(pset->properties);
715 kfree(pset);
716}
717
718static int pset_copy_entry(struct property_entry *dst,
719 const struct property_entry *src)
720{
721 const char **d, **s;
722 size_t i, nval;
723
724 dst->name = kstrdup(src->name, GFP_KERNEL);
725 if (!dst->name)
726 return -ENOMEM;
727
728 if (src->is_array) {
729 if (!src->length)
730 return -ENODATA;
731
732 if (src->is_string) {
733 nval = src->length / sizeof(const char *);
734 dst->pointer.str = kcalloc(nval, sizeof(const char *),
735 GFP_KERNEL);
736 if (!dst->pointer.str)
737 return -ENOMEM;
738
739 d = dst->pointer.str;
740 s = src->pointer.str;
741 for (i = 0; i < nval; i++) {
742 d[i] = kstrdup(s[i], GFP_KERNEL);
743 if (!d[i] && s[i])
744 return -ENOMEM;
745 }
746 } else {
747 dst->pointer.raw_data = kmemdup(src->pointer.raw_data,
748 src->length, GFP_KERNEL);
749 if (!dst->pointer.raw_data)
750 return -ENOMEM;
751 }
752 } else if (src->is_string) {
753 dst->value.str = kstrdup(src->value.str, GFP_KERNEL);
754 if (!dst->value.str && src->value.str)
755 return -ENOMEM;
756 } else {
757 dst->value.raw_data = src->value.raw_data;
758 }
759
760 dst->length = src->length;
761 dst->is_array = src->is_array;
762 dst->is_string = src->is_string;
763
764 return 0;
765}
766
767/**
768 * pset_copy_set - copies property set
769 * @pset: Property set to copy
770 *
771 * This function takes a deep copy of the given property set and returns
772 * pointer to the copy. Call device_free_property_set() to free resources
773 * allocated in this function.
774 *
775 * Return: Pointer to the new property set or error pointer.
776 */
777static struct property_set *pset_copy_set(const struct property_set *pset)
778{
779 const struct property_entry *entry;
780 struct property_set *p;
781 size_t i, n = 0;
782
783 p = kzalloc(sizeof(*p), GFP_KERNEL);
784 if (!p)
785 return ERR_PTR(-ENOMEM);
786
787 while (pset->properties[n].name)
788 n++;
789
790 p->properties = kcalloc(n + 1, sizeof(*entry), GFP_KERNEL);
791 if (!p->properties) {
792 kfree(p);
793 return ERR_PTR(-ENOMEM);
794 }
795
796 for (i = 0; i < n; i++) {
797 int ret = pset_copy_entry(&p->properties[i],
798 &pset->properties[i]);
799 if (ret) {
800 pset_free_set(p);
801 return ERR_PTR(ret);
802 }
803 }
804
805 return p;
806}
807
808/**
809 * device_remove_properties - Remove properties from a device object.
810 * @dev: Device whose properties to remove.
811 *
812 * The function removes properties previously associated to the device
813 * secondary firmware node with device_add_properties(). Memory allocated
814 * to the properties will also be released.
815 */
816void device_remove_properties(struct device *dev)
817{
818 struct fwnode_handle *fwnode;
819
820 fwnode = dev_fwnode(dev);
821 if (!fwnode)
822 return;
823 /*
824 * Pick either primary or secondary node depending which one holds
825 * the pset. If there is no real firmware node (ACPI/DT) primary
826 * will hold the pset.
827 */
828 if (is_pset_node(fwnode)) {
829 set_primary_fwnode(dev, NULL);
830 pset_free_set(to_pset_node(fwnode));
831 } else {
832 fwnode = fwnode->secondary;
833 if (!IS_ERR(fwnode) && is_pset_node(fwnode)) {
834 set_secondary_fwnode(dev, NULL);
835 pset_free_set(to_pset_node(fwnode));
836 }
837 }
838}
839EXPORT_SYMBOL_GPL(device_remove_properties);
840
841/**
842 * device_add_properties - Add a collection of properties to a device object.
843 * @dev: Device to add properties to.
844 * @properties: Collection of properties to add.
845 *
846 * Associate a collection of device properties represented by @properties with
847 * @dev as its secondary firmware node. The function takes a copy of
848 * @properties.
849 */
850int device_add_properties(struct device *dev, struct property_entry *properties)
851{
852 struct property_set *p, pset;
853
854 if (!properties)
855 return -EINVAL;
856
857 pset.properties = properties;
858
859 p = pset_copy_set(&pset);
860 if (IS_ERR(p))
861 return PTR_ERR(p);
862
863 p->fwnode.type = FWNODE_PDATA;
864 set_secondary_fwnode(dev, &p->fwnode);
865 return 0;
866}
867EXPORT_SYMBOL_GPL(device_add_properties);
868
869/**
870 * device_get_next_child_node - Return the next child node handle for a device
871 * @dev: Device to find the next child node for.
872 * @child: Handle to one of the device's child nodes or a null handle.
873 */
874struct fwnode_handle *device_get_next_child_node(struct device *dev,
875 struct fwnode_handle *child)
876{
877 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
878 struct device_node *node;
879
880 node = of_get_next_available_child(dev->of_node, to_of_node(child));
881 if (node)
882 return &node->fwnode;
883 } else if (IS_ENABLED(CONFIG_ACPI)) {
884 return acpi_get_next_subnode(dev, child);
885 }
886 return NULL;
887}
888EXPORT_SYMBOL_GPL(device_get_next_child_node);
889
890/**
891 * device_get_named_child_node - Return first matching named child node handle
892 * @dev: Device to find the named child node for.
893 * @childname: String to match child node name against.
894 */
895struct fwnode_handle *device_get_named_child_node(struct device *dev,
896 const char *childname)
897{
898 struct fwnode_handle *child;
899
900 /*
901 * Find first matching named child node of this device.
902 * For ACPI this will be a data only sub-node.
903 */
904 device_for_each_child_node(dev, child) {
905 if (is_of_node(child)) {
906 if (!of_node_cmp(to_of_node(child)->name, childname))
907 return child;
908 } else if (is_acpi_data_node(child)) {
909 if (acpi_data_node_match(child, childname))
910 return child;
911 }
912 }
913
914 return NULL;
915}
916EXPORT_SYMBOL_GPL(device_get_named_child_node);
917
918/**
919 * fwnode_handle_put - Drop reference to a device node
920 * @fwnode: Pointer to the device node to drop the reference to.
921 *
922 * This has to be used when terminating device_for_each_child_node() iteration
923 * with break or return to prevent stale device node references from being left
924 * behind.
925 */
926void fwnode_handle_put(struct fwnode_handle *fwnode)
927{
928 if (is_of_node(fwnode))
929 of_node_put(to_of_node(fwnode));
930}
931EXPORT_SYMBOL_GPL(fwnode_handle_put);
932
933/**
934 * device_get_child_node_count - return the number of child nodes for device
935 * @dev: Device to cound the child nodes for
936 */
937unsigned int device_get_child_node_count(struct device *dev)
938{
939 struct fwnode_handle *child;
940 unsigned int count = 0;
941
942 device_for_each_child_node(dev, child)
943 count++;
944
945 return count;
946}
947EXPORT_SYMBOL_GPL(device_get_child_node_count);
948
949bool device_dma_supported(struct device *dev)
950{
951 /* For DT, this is always supported.
952 * For ACPI, this depends on CCA, which
953 * is determined by the acpi_dma_supported().
954 */
955 if (IS_ENABLED(CONFIG_OF) && dev->of_node)
956 return true;
957
958 return acpi_dma_supported(ACPI_COMPANION(dev));
959}
960EXPORT_SYMBOL_GPL(device_dma_supported);
961
962enum dev_dma_attr device_get_dma_attr(struct device *dev)
963{
964 enum dev_dma_attr attr = DEV_DMA_NOT_SUPPORTED;
965
966 if (IS_ENABLED(CONFIG_OF) && dev->of_node) {
967 if (of_dma_is_coherent(dev->of_node))
968 attr = DEV_DMA_COHERENT;
969 else
970 attr = DEV_DMA_NON_COHERENT;
971 } else
972 attr = acpi_get_dma_attr(ACPI_COMPANION(dev));
973
974 return attr;
975}
976EXPORT_SYMBOL_GPL(device_get_dma_attr);
977
978/**
979 * device_get_phy_mode - Get phy mode for given device
980 * @dev: Pointer to the given device
981 *
982 * The function gets phy interface string from property 'phy-mode' or
983 * 'phy-connection-type', and return its index in phy_modes table, or errno in
984 * error case.
985 */
986int device_get_phy_mode(struct device *dev)
987{
988 const char *pm;
989 int err, i;
990
991 err = device_property_read_string(dev, "phy-mode", &pm);
992 if (err < 0)
993 err = device_property_read_string(dev,
994 "phy-connection-type", &pm);
995 if (err < 0)
996 return err;
997
998 for (i = 0; i < PHY_INTERFACE_MODE_MAX; i++)
999 if (!strcasecmp(pm, phy_modes(i)))
1000 return i;
1001
1002 return -ENODEV;
1003}
1004EXPORT_SYMBOL_GPL(device_get_phy_mode);
1005
1006static void *device_get_mac_addr(struct device *dev,
1007 const char *name, char *addr,
1008 int alen)
1009{
1010 int ret = device_property_read_u8_array(dev, name, addr, alen);
1011
1012 if (ret == 0 && alen == ETH_ALEN && is_valid_ether_addr(addr))
1013 return addr;
1014 return NULL;
1015}
1016
1017/**
1018 * device_get_mac_address - Get the MAC for a given device
1019 * @dev: Pointer to the device
1020 * @addr: Address of buffer to store the MAC in
1021 * @alen: Length of the buffer pointed to by addr, should be ETH_ALEN
1022 *
1023 * Search the firmware node for the best MAC address to use. 'mac-address' is
1024 * checked first, because that is supposed to contain to "most recent" MAC
1025 * address. If that isn't set, then 'local-mac-address' is checked next,
1026 * because that is the default address. If that isn't set, then the obsolete
1027 * 'address' is checked, just in case we're using an old device tree.
1028 *
1029 * Note that the 'address' property is supposed to contain a virtual address of
1030 * the register set, but some DTS files have redefined that property to be the
1031 * MAC address.
1032 *
1033 * All-zero MAC addresses are rejected, because those could be properties that
1034 * exist in the firmware tables, but were not updated by the firmware. For
1035 * example, the DTS could define 'mac-address' and 'local-mac-address', with
1036 * zero MAC addresses. Some older U-Boots only initialized 'local-mac-address'.
1037 * In this case, the real MAC is in 'local-mac-address', and 'mac-address'
1038 * exists but is all zeros.
1039*/
1040void *device_get_mac_address(struct device *dev, char *addr, int alen)
1041{
1042 char *res;
1043
1044 res = device_get_mac_addr(dev, "mac-address", addr, alen);
1045 if (res)
1046 return res;
1047
1048 res = device_get_mac_addr(dev, "local-mac-address", addr, alen);
1049 if (res)
1050 return res;
1051
1052 return device_get_mac_addr(dev, "address", addr, alen);
1053}
1054EXPORT_SYMBOL(device_get_mac_address);