1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Thunderbolt XDomain property support |
4 | * |
5 | * Copyright (C) 2017, Intel Corporation |
6 | * Authors: Michael Jamet <michael.jamet@intel.com> |
7 | * Mika Westerberg <mika.westerberg@linux.intel.com> |
8 | */ |
9 | |
10 | #include <linux/err.h> |
11 | #include <linux/slab.h> |
12 | #include <linux/string.h> |
13 | #include <linux/uuid.h> |
14 | #include <linux/thunderbolt.h> |
15 | |
16 | struct tb_property_entry { |
17 | u32 key_hi; |
18 | u32 key_lo; |
19 | u16 length; |
20 | u8 reserved; |
21 | u8 type; |
22 | u32 value; |
23 | }; |
24 | |
25 | struct tb_property_rootdir_entry { |
26 | u32 magic; |
27 | u32 length; |
28 | struct tb_property_entry entries[]; |
29 | }; |
30 | |
31 | struct tb_property_dir_entry { |
32 | u32 uuid[4]; |
33 | struct tb_property_entry entries[]; |
34 | }; |
35 | |
36 | #define TB_PROPERTY_ROOTDIR_MAGIC 0x55584401 |
37 | |
38 | static struct tb_property_dir *__tb_property_parse_dir(const u32 *block, |
39 | size_t block_len, unsigned int dir_offset, size_t dir_len, |
40 | bool is_root); |
41 | |
42 | static inline void parse_dwdata(void *dst, const void *src, size_t dwords) |
43 | { |
44 | be32_to_cpu_array(dst, src, len: dwords); |
45 | } |
46 | |
47 | static inline void format_dwdata(void *dst, const void *src, size_t dwords) |
48 | { |
49 | cpu_to_be32_array(dst, src, len: dwords); |
50 | } |
51 | |
52 | static bool tb_property_entry_valid(const struct tb_property_entry *entry, |
53 | size_t block_len) |
54 | { |
55 | switch (entry->type) { |
56 | case TB_PROPERTY_TYPE_DIRECTORY: |
57 | case TB_PROPERTY_TYPE_DATA: |
58 | case TB_PROPERTY_TYPE_TEXT: |
59 | if (entry->length > block_len) |
60 | return false; |
61 | if (entry->value + entry->length > block_len) |
62 | return false; |
63 | break; |
64 | |
65 | case TB_PROPERTY_TYPE_VALUE: |
66 | if (entry->length != 1) |
67 | return false; |
68 | break; |
69 | } |
70 | |
71 | return true; |
72 | } |
73 | |
74 | static bool tb_property_key_valid(const char *key) |
75 | { |
76 | return key && strlen(key) <= TB_PROPERTY_KEY_SIZE; |
77 | } |
78 | |
79 | static struct tb_property * |
80 | tb_property_alloc(const char *key, enum tb_property_type type) |
81 | { |
82 | struct tb_property *property; |
83 | |
84 | property = kzalloc(size: sizeof(*property), GFP_KERNEL); |
85 | if (!property) |
86 | return NULL; |
87 | |
88 | strcpy(p: property->key, q: key); |
89 | property->type = type; |
90 | INIT_LIST_HEAD(list: &property->list); |
91 | |
92 | return property; |
93 | } |
94 | |
95 | static struct tb_property *tb_property_parse(const u32 *block, size_t block_len, |
96 | const struct tb_property_entry *entry) |
97 | { |
98 | char key[TB_PROPERTY_KEY_SIZE + 1]; |
99 | struct tb_property *property; |
100 | struct tb_property_dir *dir; |
101 | |
102 | if (!tb_property_entry_valid(entry, block_len)) |
103 | return NULL; |
104 | |
105 | parse_dwdata(dst: key, src: entry, dwords: 2); |
106 | key[TB_PROPERTY_KEY_SIZE] = '\0'; |
107 | |
108 | property = tb_property_alloc(key, type: entry->type); |
109 | if (!property) |
110 | return NULL; |
111 | |
112 | property->length = entry->length; |
113 | |
114 | switch (property->type) { |
115 | case TB_PROPERTY_TYPE_DIRECTORY: |
116 | dir = __tb_property_parse_dir(block, block_len, dir_offset: entry->value, |
117 | dir_len: entry->length, is_root: false); |
118 | if (!dir) { |
119 | kfree(objp: property); |
120 | return NULL; |
121 | } |
122 | property->value.dir = dir; |
123 | break; |
124 | |
125 | case TB_PROPERTY_TYPE_DATA: |
126 | property->value.data = kcalloc(n: property->length, size: sizeof(u32), |
127 | GFP_KERNEL); |
128 | if (!property->value.data) { |
129 | kfree(objp: property); |
130 | return NULL; |
131 | } |
132 | parse_dwdata(dst: property->value.data, src: block + entry->value, |
133 | dwords: entry->length); |
134 | break; |
135 | |
136 | case TB_PROPERTY_TYPE_TEXT: |
137 | property->value.text = kcalloc(n: property->length, size: sizeof(u32), |
138 | GFP_KERNEL); |
139 | if (!property->value.text) { |
140 | kfree(objp: property); |
141 | return NULL; |
142 | } |
143 | parse_dwdata(dst: property->value.text, src: block + entry->value, |
144 | dwords: entry->length); |
145 | /* Force null termination */ |
146 | property->value.text[property->length * 4 - 1] = '\0'; |
147 | break; |
148 | |
149 | case TB_PROPERTY_TYPE_VALUE: |
150 | property->value.immediate = entry->value; |
151 | break; |
152 | |
153 | default: |
154 | property->type = TB_PROPERTY_TYPE_UNKNOWN; |
155 | break; |
156 | } |
157 | |
158 | return property; |
159 | } |
160 | |
161 | static struct tb_property_dir *__tb_property_parse_dir(const u32 *block, |
162 | size_t block_len, unsigned int dir_offset, size_t dir_len, bool is_root) |
163 | { |
164 | const struct tb_property_entry *entries; |
165 | size_t i, content_len, nentries; |
166 | unsigned int content_offset; |
167 | struct tb_property_dir *dir; |
168 | |
169 | dir = kzalloc(size: sizeof(*dir), GFP_KERNEL); |
170 | if (!dir) |
171 | return NULL; |
172 | |
173 | if (is_root) { |
174 | content_offset = dir_offset + 2; |
175 | content_len = dir_len; |
176 | } else { |
177 | dir->uuid = kmemdup(p: &block[dir_offset], size: sizeof(*dir->uuid), |
178 | GFP_KERNEL); |
179 | if (!dir->uuid) { |
180 | tb_property_free_dir(dir); |
181 | return NULL; |
182 | } |
183 | content_offset = dir_offset + 4; |
184 | content_len = dir_len - 4; /* Length includes UUID */ |
185 | } |
186 | |
187 | entries = (const struct tb_property_entry *)&block[content_offset]; |
188 | nentries = content_len / (sizeof(*entries) / 4); |
189 | |
190 | INIT_LIST_HEAD(list: &dir->properties); |
191 | |
192 | for (i = 0; i < nentries; i++) { |
193 | struct tb_property *property; |
194 | |
195 | property = tb_property_parse(block, block_len, entry: &entries[i]); |
196 | if (!property) { |
197 | tb_property_free_dir(dir); |
198 | return NULL; |
199 | } |
200 | |
201 | list_add_tail(new: &property->list, head: &dir->properties); |
202 | } |
203 | |
204 | return dir; |
205 | } |
206 | |
207 | /** |
208 | * tb_property_parse_dir() - Parses properties from given property block |
209 | * @block: Property block to parse |
210 | * @block_len: Number of dword elements in the property block |
211 | * |
212 | * This function parses the XDomain properties data block into format that |
213 | * can be traversed using the helper functions provided by this module. |
214 | * Upon success returns the parsed directory. In case of error returns |
215 | * %NULL. The resulting &struct tb_property_dir needs to be released by |
216 | * calling tb_property_free_dir() when not needed anymore. |
217 | * |
218 | * The @block is expected to be root directory. |
219 | */ |
220 | struct tb_property_dir *tb_property_parse_dir(const u32 *block, |
221 | size_t block_len) |
222 | { |
223 | const struct tb_property_rootdir_entry *rootdir = |
224 | (const struct tb_property_rootdir_entry *)block; |
225 | |
226 | if (rootdir->magic != TB_PROPERTY_ROOTDIR_MAGIC) |
227 | return NULL; |
228 | if (rootdir->length > block_len) |
229 | return NULL; |
230 | |
231 | return __tb_property_parse_dir(block, block_len, dir_offset: 0, dir_len: rootdir->length, |
232 | is_root: true); |
233 | } |
234 | |
235 | /** |
236 | * tb_property_create_dir() - Creates new property directory |
237 | * @uuid: UUID used to identify the particular directory |
238 | * |
239 | * Creates new, empty property directory. If @uuid is %NULL then the |
240 | * directory is assumed to be root directory. |
241 | */ |
242 | struct tb_property_dir *tb_property_create_dir(const uuid_t *uuid) |
243 | { |
244 | struct tb_property_dir *dir; |
245 | |
246 | dir = kzalloc(size: sizeof(*dir), GFP_KERNEL); |
247 | if (!dir) |
248 | return NULL; |
249 | |
250 | INIT_LIST_HEAD(list: &dir->properties); |
251 | if (uuid) { |
252 | dir->uuid = kmemdup(p: uuid, size: sizeof(*dir->uuid), GFP_KERNEL); |
253 | if (!dir->uuid) { |
254 | kfree(objp: dir); |
255 | return NULL; |
256 | } |
257 | } |
258 | |
259 | return dir; |
260 | } |
261 | EXPORT_SYMBOL_GPL(tb_property_create_dir); |
262 | |
263 | static void tb_property_free(struct tb_property *property) |
264 | { |
265 | switch (property->type) { |
266 | case TB_PROPERTY_TYPE_DIRECTORY: |
267 | tb_property_free_dir(dir: property->value.dir); |
268 | break; |
269 | |
270 | case TB_PROPERTY_TYPE_DATA: |
271 | kfree(objp: property->value.data); |
272 | break; |
273 | |
274 | case TB_PROPERTY_TYPE_TEXT: |
275 | kfree(objp: property->value.text); |
276 | break; |
277 | |
278 | default: |
279 | break; |
280 | } |
281 | |
282 | kfree(objp: property); |
283 | } |
284 | |
285 | /** |
286 | * tb_property_free_dir() - Release memory allocated for property directory |
287 | * @dir: Directory to release |
288 | * |
289 | * This will release all the memory the directory occupies including all |
290 | * descendants. It is OK to pass %NULL @dir, then the function does |
291 | * nothing. |
292 | */ |
293 | void tb_property_free_dir(struct tb_property_dir *dir) |
294 | { |
295 | struct tb_property *property, *tmp; |
296 | |
297 | if (!dir) |
298 | return; |
299 | |
300 | list_for_each_entry_safe(property, tmp, &dir->properties, list) { |
301 | list_del(entry: &property->list); |
302 | tb_property_free(property); |
303 | } |
304 | kfree(objp: dir->uuid); |
305 | kfree(objp: dir); |
306 | } |
307 | EXPORT_SYMBOL_GPL(tb_property_free_dir); |
308 | |
309 | static size_t tb_property_dir_length(const struct tb_property_dir *dir, |
310 | bool recurse, size_t *data_len) |
311 | { |
312 | const struct tb_property *property; |
313 | size_t len = 0; |
314 | |
315 | if (dir->uuid) |
316 | len += sizeof(*dir->uuid) / 4; |
317 | else |
318 | len += sizeof(struct tb_property_rootdir_entry) / 4; |
319 | |
320 | list_for_each_entry(property, &dir->properties, list) { |
321 | len += sizeof(struct tb_property_entry) / 4; |
322 | |
323 | switch (property->type) { |
324 | case TB_PROPERTY_TYPE_DIRECTORY: |
325 | if (recurse) { |
326 | len += tb_property_dir_length( |
327 | dir: property->value.dir, recurse, data_len); |
328 | } |
329 | /* Reserve dword padding after each directory */ |
330 | if (data_len) |
331 | *data_len += 1; |
332 | break; |
333 | |
334 | case TB_PROPERTY_TYPE_DATA: |
335 | case TB_PROPERTY_TYPE_TEXT: |
336 | if (data_len) |
337 | *data_len += property->length; |
338 | break; |
339 | |
340 | default: |
341 | break; |
342 | } |
343 | } |
344 | |
345 | return len; |
346 | } |
347 | |
348 | static ssize_t __tb_property_format_dir(const struct tb_property_dir *dir, |
349 | u32 *block, unsigned int start_offset, size_t block_len) |
350 | { |
351 | unsigned int data_offset, dir_end; |
352 | const struct tb_property *property; |
353 | struct tb_property_entry *entry; |
354 | size_t dir_len, data_len = 0; |
355 | int ret; |
356 | |
357 | /* |
358 | * The structure of property block looks like following. Leaf |
359 | * data/text is included right after the directory and each |
360 | * directory follows each other (even nested ones). |
361 | * |
362 | * +----------+ <-- start_offset |
363 | * | header | <-- root directory header |
364 | * +----------+ --- |
365 | * | entry 0 | -^--------------------. |
366 | * +----------+ | | |
367 | * | entry 1 | -|--------------------|--. |
368 | * +----------+ | | | |
369 | * | entry 2 | -|-----------------. | | |
370 | * +----------+ | | | | |
371 | * : : | dir_len | | | |
372 | * . . | | | | |
373 | * : : | | | | |
374 | * +----------+ | | | | |
375 | * | entry n | v | | | |
376 | * +----------+ <-- data_offset | | | |
377 | * | data 0 | <------------------|--' | |
378 | * +----------+ | | |
379 | * | data 1 | <------------------|-----' |
380 | * +----------+ | |
381 | * | 00000000 | padding | |
382 | * +----------+ <-- dir_end <------' |
383 | * | UUID | <-- directory UUID (child directory) |
384 | * +----------+ |
385 | * | entry 0 | |
386 | * +----------+ |
387 | * | entry 1 | |
388 | * +----------+ |
389 | * : : |
390 | * . . |
391 | * : : |
392 | * +----------+ |
393 | * | entry n | |
394 | * +----------+ |
395 | * | data 0 | |
396 | * +----------+ |
397 | * |
398 | * We use dir_end to hold pointer to the end of the directory. It |
399 | * will increase as we add directories and each directory should be |
400 | * added starting from previous dir_end. |
401 | */ |
402 | dir_len = tb_property_dir_length(dir, recurse: false, data_len: &data_len); |
403 | data_offset = start_offset + dir_len; |
404 | dir_end = start_offset + data_len + dir_len; |
405 | |
406 | if (data_offset > dir_end) |
407 | return -EINVAL; |
408 | if (dir_end > block_len) |
409 | return -EINVAL; |
410 | |
411 | /* Write headers first */ |
412 | if (dir->uuid) { |
413 | struct tb_property_dir_entry *pe; |
414 | |
415 | pe = (struct tb_property_dir_entry *)&block[start_offset]; |
416 | memcpy(pe->uuid, dir->uuid, sizeof(pe->uuid)); |
417 | entry = pe->entries; |
418 | } else { |
419 | struct tb_property_rootdir_entry *re; |
420 | |
421 | re = (struct tb_property_rootdir_entry *)&block[start_offset]; |
422 | re->magic = TB_PROPERTY_ROOTDIR_MAGIC; |
423 | re->length = dir_len - sizeof(*re) / 4; |
424 | entry = re->entries; |
425 | } |
426 | |
427 | list_for_each_entry(property, &dir->properties, list) { |
428 | const struct tb_property_dir *child; |
429 | |
430 | format_dwdata(dst: entry, src: property->key, dwords: 2); |
431 | entry->type = property->type; |
432 | |
433 | switch (property->type) { |
434 | case TB_PROPERTY_TYPE_DIRECTORY: |
435 | child = property->value.dir; |
436 | ret = __tb_property_format_dir(dir: child, block, start_offset: dir_end, |
437 | block_len); |
438 | if (ret < 0) |
439 | return ret; |
440 | entry->length = tb_property_dir_length(dir: child, recurse: false, |
441 | NULL); |
442 | entry->value = dir_end; |
443 | dir_end = ret; |
444 | break; |
445 | |
446 | case TB_PROPERTY_TYPE_DATA: |
447 | format_dwdata(dst: &block[data_offset], src: property->value.data, |
448 | dwords: property->length); |
449 | entry->length = property->length; |
450 | entry->value = data_offset; |
451 | data_offset += entry->length; |
452 | break; |
453 | |
454 | case TB_PROPERTY_TYPE_TEXT: |
455 | format_dwdata(dst: &block[data_offset], src: property->value.text, |
456 | dwords: property->length); |
457 | entry->length = property->length; |
458 | entry->value = data_offset; |
459 | data_offset += entry->length; |
460 | break; |
461 | |
462 | case TB_PROPERTY_TYPE_VALUE: |
463 | entry->length = property->length; |
464 | entry->value = property->value.immediate; |
465 | break; |
466 | |
467 | default: |
468 | break; |
469 | } |
470 | |
471 | entry++; |
472 | } |
473 | |
474 | return dir_end; |
475 | } |
476 | |
477 | /** |
478 | * tb_property_format_dir() - Formats directory to the packed XDomain format |
479 | * @dir: Directory to format |
480 | * @block: Property block where the packed data is placed |
481 | * @block_len: Length of the property block |
482 | * |
483 | * This function formats the directory to the packed format that can be |
484 | * then send over the thunderbolt fabric to receiving host. Returns %0 in |
485 | * case of success and negative errno on faulure. Passing %NULL in @block |
486 | * returns number of entries the block takes. |
487 | */ |
488 | ssize_t tb_property_format_dir(const struct tb_property_dir *dir, u32 *block, |
489 | size_t block_len) |
490 | { |
491 | ssize_t ret; |
492 | |
493 | if (!block) { |
494 | size_t dir_len, data_len = 0; |
495 | |
496 | dir_len = tb_property_dir_length(dir, recurse: true, data_len: &data_len); |
497 | return dir_len + data_len; |
498 | } |
499 | |
500 | ret = __tb_property_format_dir(dir, block, start_offset: 0, block_len); |
501 | return ret < 0 ? ret : 0; |
502 | } |
503 | |
504 | /** |
505 | * tb_property_copy_dir() - Take a deep copy of directory |
506 | * @dir: Directory to copy |
507 | * |
508 | * This function takes a deep copy of @dir and returns back the copy. In |
509 | * case of error returns %NULL. The resulting directory needs to be |
510 | * released by calling tb_property_free_dir(). |
511 | */ |
512 | struct tb_property_dir *tb_property_copy_dir(const struct tb_property_dir *dir) |
513 | { |
514 | struct tb_property *property, *p = NULL; |
515 | struct tb_property_dir *d; |
516 | |
517 | if (!dir) |
518 | return NULL; |
519 | |
520 | d = tb_property_create_dir(dir->uuid); |
521 | if (!d) |
522 | return NULL; |
523 | |
524 | list_for_each_entry(property, &dir->properties, list) { |
525 | struct tb_property *p; |
526 | |
527 | p = tb_property_alloc(key: property->key, type: property->type); |
528 | if (!p) |
529 | goto err_free; |
530 | |
531 | p->length = property->length; |
532 | |
533 | switch (property->type) { |
534 | case TB_PROPERTY_TYPE_DIRECTORY: |
535 | p->value.dir = tb_property_copy_dir(dir: property->value.dir); |
536 | if (!p->value.dir) |
537 | goto err_free; |
538 | break; |
539 | |
540 | case TB_PROPERTY_TYPE_DATA: |
541 | p->value.data = kmemdup(p: property->value.data, |
542 | size: property->length * 4, |
543 | GFP_KERNEL); |
544 | if (!p->value.data) |
545 | goto err_free; |
546 | break; |
547 | |
548 | case TB_PROPERTY_TYPE_TEXT: |
549 | p->value.text = kzalloc(size: p->length * 4, GFP_KERNEL); |
550 | if (!p->value.text) |
551 | goto err_free; |
552 | strcpy(p: p->value.text, q: property->value.text); |
553 | break; |
554 | |
555 | case TB_PROPERTY_TYPE_VALUE: |
556 | p->value.immediate = property->value.immediate; |
557 | break; |
558 | |
559 | default: |
560 | break; |
561 | } |
562 | |
563 | list_add_tail(new: &p->list, head: &d->properties); |
564 | } |
565 | |
566 | return d; |
567 | |
568 | err_free: |
569 | kfree(objp: p); |
570 | tb_property_free_dir(d); |
571 | |
572 | return NULL; |
573 | } |
574 | |
575 | /** |
576 | * tb_property_add_immediate() - Add immediate property to directory |
577 | * @parent: Directory to add the property |
578 | * @key: Key for the property |
579 | * @value: Immediate value to store with the property |
580 | */ |
581 | int tb_property_add_immediate(struct tb_property_dir *parent, const char *key, |
582 | u32 value) |
583 | { |
584 | struct tb_property *property; |
585 | |
586 | if (!tb_property_key_valid(key)) |
587 | return -EINVAL; |
588 | |
589 | property = tb_property_alloc(key, type: TB_PROPERTY_TYPE_VALUE); |
590 | if (!property) |
591 | return -ENOMEM; |
592 | |
593 | property->length = 1; |
594 | property->value.immediate = value; |
595 | |
596 | list_add_tail(new: &property->list, head: &parent->properties); |
597 | return 0; |
598 | } |
599 | EXPORT_SYMBOL_GPL(tb_property_add_immediate); |
600 | |
601 | /** |
602 | * tb_property_add_data() - Adds arbitrary data property to directory |
603 | * @parent: Directory to add the property |
604 | * @key: Key for the property |
605 | * @buf: Data buffer to add |
606 | * @buflen: Number of bytes in the data buffer |
607 | * |
608 | * Function takes a copy of @buf and adds it to the directory. |
609 | */ |
610 | int tb_property_add_data(struct tb_property_dir *parent, const char *key, |
611 | const void *buf, size_t buflen) |
612 | { |
613 | /* Need to pad to dword boundary */ |
614 | size_t size = round_up(buflen, 4); |
615 | struct tb_property *property; |
616 | |
617 | if (!tb_property_key_valid(key)) |
618 | return -EINVAL; |
619 | |
620 | property = tb_property_alloc(key, type: TB_PROPERTY_TYPE_DATA); |
621 | if (!property) |
622 | return -ENOMEM; |
623 | |
624 | property->length = size / 4; |
625 | property->value.data = kzalloc(size, GFP_KERNEL); |
626 | if (!property->value.data) { |
627 | kfree(objp: property); |
628 | return -ENOMEM; |
629 | } |
630 | |
631 | memcpy(property->value.data, buf, buflen); |
632 | |
633 | list_add_tail(new: &property->list, head: &parent->properties); |
634 | return 0; |
635 | } |
636 | EXPORT_SYMBOL_GPL(tb_property_add_data); |
637 | |
638 | /** |
639 | * tb_property_add_text() - Adds string property to directory |
640 | * @parent: Directory to add the property |
641 | * @key: Key for the property |
642 | * @text: String to add |
643 | * |
644 | * Function takes a copy of @text and adds it to the directory. |
645 | */ |
646 | int tb_property_add_text(struct tb_property_dir *parent, const char *key, |
647 | const char *text) |
648 | { |
649 | /* Need to pad to dword boundary */ |
650 | size_t size = round_up(strlen(text) + 1, 4); |
651 | struct tb_property *property; |
652 | |
653 | if (!tb_property_key_valid(key)) |
654 | return -EINVAL; |
655 | |
656 | property = tb_property_alloc(key, type: TB_PROPERTY_TYPE_TEXT); |
657 | if (!property) |
658 | return -ENOMEM; |
659 | |
660 | property->length = size / 4; |
661 | property->value.text = kzalloc(size, GFP_KERNEL); |
662 | if (!property->value.text) { |
663 | kfree(objp: property); |
664 | return -ENOMEM; |
665 | } |
666 | |
667 | strcpy(p: property->value.text, q: text); |
668 | |
669 | list_add_tail(new: &property->list, head: &parent->properties); |
670 | return 0; |
671 | } |
672 | EXPORT_SYMBOL_GPL(tb_property_add_text); |
673 | |
674 | /** |
675 | * tb_property_add_dir() - Adds a directory to the parent directory |
676 | * @parent: Directory to add the property |
677 | * @key: Key for the property |
678 | * @dir: Directory to add |
679 | */ |
680 | int tb_property_add_dir(struct tb_property_dir *parent, const char *key, |
681 | struct tb_property_dir *dir) |
682 | { |
683 | struct tb_property *property; |
684 | |
685 | if (!tb_property_key_valid(key)) |
686 | return -EINVAL; |
687 | |
688 | property = tb_property_alloc(key, type: TB_PROPERTY_TYPE_DIRECTORY); |
689 | if (!property) |
690 | return -ENOMEM; |
691 | |
692 | property->value.dir = dir; |
693 | |
694 | list_add_tail(new: &property->list, head: &parent->properties); |
695 | return 0; |
696 | } |
697 | EXPORT_SYMBOL_GPL(tb_property_add_dir); |
698 | |
699 | /** |
700 | * tb_property_remove() - Removes property from a parent directory |
701 | * @property: Property to remove |
702 | * |
703 | * Note memory for @property is released as well so it is not allowed to |
704 | * touch the object after call to this function. |
705 | */ |
706 | void tb_property_remove(struct tb_property *property) |
707 | { |
708 | list_del(entry: &property->list); |
709 | kfree(objp: property); |
710 | } |
711 | EXPORT_SYMBOL_GPL(tb_property_remove); |
712 | |
713 | /** |
714 | * tb_property_find() - Find a property from a directory |
715 | * @dir: Directory where the property is searched |
716 | * @key: Key to look for |
717 | * @type: Type of the property |
718 | * |
719 | * Finds and returns property from the given directory. Does not recurse |
720 | * into sub-directories. Returns %NULL if the property was not found. |
721 | */ |
722 | struct tb_property *tb_property_find(struct tb_property_dir *dir, |
723 | const char *key, enum tb_property_type type) |
724 | { |
725 | struct tb_property *property; |
726 | |
727 | list_for_each_entry(property, &dir->properties, list) { |
728 | if (property->type == type && !strcmp(property->key, key)) |
729 | return property; |
730 | } |
731 | |
732 | return NULL; |
733 | } |
734 | EXPORT_SYMBOL_GPL(tb_property_find); |
735 | |
736 | /** |
737 | * tb_property_get_next() - Get next property from directory |
738 | * @dir: Directory holding properties |
739 | * @prev: Previous property in the directory (%NULL returns the first) |
740 | */ |
741 | struct tb_property *tb_property_get_next(struct tb_property_dir *dir, |
742 | struct tb_property *prev) |
743 | { |
744 | if (prev) { |
745 | if (list_is_last(list: &prev->list, head: &dir->properties)) |
746 | return NULL; |
747 | return list_next_entry(prev, list); |
748 | } |
749 | return list_first_entry_or_null(&dir->properties, struct tb_property, |
750 | list); |
751 | } |
752 | EXPORT_SYMBOL_GPL(tb_property_get_next); |
753 | |