1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Software nodes for the firmware node framework. 4 * 5 * Copyright (C) 2018, Intel Corporation 6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com> 7 */ 8 9 #include <linux/device.h> 10 #include <linux/kernel.h> 11 #include <linux/property.h> 12 #include <linux/slab.h> 13 14 #include "base.h" 15 16 struct swnode { 17 struct kobject kobj; 18 struct fwnode_handle fwnode; 19 const struct software_node *node; 20 int id; 21 22 /* hierarchy */ 23 struct ida child_ids; 24 struct list_head entry; 25 struct list_head children; 26 struct swnode *parent; 27 28 unsigned int allocated:1; 29 unsigned int managed:1; 30 }; 31 32 static DEFINE_IDA(swnode_root_ids); 33 static struct kset *swnode_kset; 34 35 #define kobj_to_swnode(_kobj_) container_of(_kobj_, struct swnode, kobj) 36 37 static const struct fwnode_operations software_node_ops; 38 39 bool is_software_node(const struct fwnode_handle *fwnode) 40 { 41 return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &software_node_ops; 42 } 43 EXPORT_SYMBOL_GPL(is_software_node); 44 45 #define to_swnode(__fwnode) \ 46 ({ \ 47 typeof(__fwnode) __to_swnode_fwnode = __fwnode; \ 48 \ 49 is_software_node(__to_swnode_fwnode) ? \ 50 container_of(__to_swnode_fwnode, \ 51 struct swnode, fwnode) : NULL; \ 52 }) 53 54 static inline struct swnode *dev_to_swnode(struct device *dev) 55 { 56 struct fwnode_handle *fwnode = dev_fwnode(dev); 57 58 if (!fwnode) 59 return NULL; 60 61 if (!is_software_node(fwnode)) 62 fwnode = fwnode->secondary; 63 64 return to_swnode(fwnode); 65 } 66 67 static struct swnode * 68 software_node_to_swnode(const struct software_node *node) 69 { 70 struct swnode *swnode = NULL; 71 struct kobject *k; 72 73 if (!node) 74 return NULL; 75 76 spin_lock(&swnode_kset->list_lock); 77 78 list_for_each_entry(k, &swnode_kset->list, entry) { 79 swnode = kobj_to_swnode(k); 80 if (swnode->node == node) 81 break; 82 swnode = NULL; 83 } 84 85 spin_unlock(&swnode_kset->list_lock); 86 87 return swnode; 88 } 89 90 const struct software_node *to_software_node(const struct fwnode_handle *fwnode) 91 { 92 const struct swnode *swnode = to_swnode(fwnode); 93 94 return swnode ? swnode->node : NULL; 95 } 96 EXPORT_SYMBOL_GPL(to_software_node); 97 98 struct fwnode_handle *software_node_fwnode(const struct software_node *node) 99 { 100 struct swnode *swnode = software_node_to_swnode(node); 101 102 return swnode ? &swnode->fwnode : NULL; 103 } 104 EXPORT_SYMBOL_GPL(software_node_fwnode); 105 106 /* -------------------------------------------------------------------------- */ 107 /* property_entry processing */ 108 109 static const struct property_entry * 110 property_entry_get(const struct property_entry *prop, const char *name) 111 { 112 if (!prop) 113 return NULL; 114 115 for (; prop->name; prop++) 116 if (!strcmp(name, prop->name)) 117 return prop; 118 119 return NULL; 120 } 121 122 static const void *property_get_pointer(const struct property_entry *prop) 123 { 124 if (!prop->length) 125 return NULL; 126 127 return prop->is_inline ? &prop->value : prop->pointer; 128 } 129 130 static const void *property_entry_find(const struct property_entry *props, 131 const char *propname, size_t length) 132 { 133 const struct property_entry *prop; 134 const void *pointer; 135 136 prop = property_entry_get(props, propname); 137 if (!prop) 138 return ERR_PTR(-EINVAL); 139 pointer = property_get_pointer(prop); 140 if (!pointer) 141 return ERR_PTR(-ENODATA); 142 if (length > prop->length) 143 return ERR_PTR(-EOVERFLOW); 144 return pointer; 145 } 146 147 static int 148 property_entry_count_elems_of_size(const struct property_entry *props, 149 const char *propname, size_t length) 150 { 151 const struct property_entry *prop; 152 153 prop = property_entry_get(props, propname); 154 if (!prop) 155 return -EINVAL; 156 157 return prop->length / length; 158 } 159 160 static int property_entry_read_int_array(const struct property_entry *props, 161 const char *name, 162 unsigned int elem_size, void *val, 163 size_t nval) 164 { 165 const void *pointer; 166 size_t length; 167 168 if (!val) 169 return property_entry_count_elems_of_size(props, name, 170 elem_size); 171 172 if (!is_power_of_2(elem_size) || elem_size > sizeof(u64)) 173 return -ENXIO; 174 175 length = nval * elem_size; 176 177 pointer = property_entry_find(props, name, length); 178 if (IS_ERR(pointer)) 179 return PTR_ERR(pointer); 180 181 memcpy(val, pointer, length); 182 return 0; 183 } 184 185 static int property_entry_read_string_array(const struct property_entry *props, 186 const char *propname, 187 const char **strings, size_t nval) 188 { 189 const void *pointer; 190 size_t length; 191 int array_len; 192 193 /* Find out the array length. */ 194 array_len = property_entry_count_elems_of_size(props, propname, 195 sizeof(const char *)); 196 if (array_len < 0) 197 return array_len; 198 199 /* Return how many there are if strings is NULL. */ 200 if (!strings) 201 return array_len; 202 203 array_len = min_t(size_t, nval, array_len); 204 length = array_len * sizeof(*strings); 205 206 pointer = property_entry_find(props, propname, length); 207 if (IS_ERR(pointer)) 208 return PTR_ERR(pointer); 209 210 memcpy(strings, pointer, length); 211 212 return array_len; 213 } 214 215 static void property_entry_free_data(const struct property_entry *p) 216 { 217 const char * const *src_str; 218 size_t i, nval; 219 220 if (p->type == DEV_PROP_STRING) { 221 src_str = property_get_pointer(p); 222 nval = p->length / sizeof(*src_str); 223 for (i = 0; i < nval; i++) 224 kfree(src_str[i]); 225 } 226 227 if (!p->is_inline) 228 kfree(p->pointer); 229 230 kfree(p->name); 231 } 232 233 static bool property_copy_string_array(const char **dst_ptr, 234 const char * const *src_ptr, 235 size_t nval) 236 { 237 int i; 238 239 for (i = 0; i < nval; i++) { 240 dst_ptr[i] = kstrdup(src_ptr[i], GFP_KERNEL); 241 if (!dst_ptr[i] && src_ptr[i]) { 242 while (--i >= 0) 243 kfree(dst_ptr[i]); 244 return false; 245 } 246 } 247 248 return true; 249 } 250 251 static int property_entry_copy_data(struct property_entry *dst, 252 const struct property_entry *src) 253 { 254 const void *pointer = property_get_pointer(src); 255 void *dst_ptr; 256 size_t nval; 257 258 /* 259 * Properties with no data should not be marked as stored 260 * out of line. 261 */ 262 if (!src->is_inline && !src->length) 263 return -ENODATA; 264 265 /* 266 * Reference properties are never stored inline as 267 * they are too big. 268 */ 269 if (src->type == DEV_PROP_REF && src->is_inline) 270 return -EINVAL; 271 272 if (src->length <= sizeof(dst->value)) { 273 dst_ptr = &dst->value; 274 dst->is_inline = true; 275 } else { 276 dst_ptr = kmalloc(src->length, GFP_KERNEL); 277 if (!dst_ptr) 278 return -ENOMEM; 279 dst->pointer = dst_ptr; 280 } 281 282 if (src->type == DEV_PROP_STRING) { 283 nval = src->length / sizeof(const char *); 284 if (!property_copy_string_array(dst_ptr, pointer, nval)) { 285 if (!dst->is_inline) 286 kfree(dst->pointer); 287 return -ENOMEM; 288 } 289 } else { 290 memcpy(dst_ptr, pointer, src->length); 291 } 292 293 dst->length = src->length; 294 dst->type = src->type; 295 dst->name = kstrdup(src->name, GFP_KERNEL); 296 if (!dst->name) { 297 property_entry_free_data(dst); 298 return -ENOMEM; 299 } 300 301 return 0; 302 } 303 304 /** 305 * property_entries_dup - duplicate array of properties 306 * @properties: array of properties to copy 307 * 308 * This function creates a deep copy of the given NULL-terminated array 309 * of property entries. 310 */ 311 struct property_entry * 312 property_entries_dup(const struct property_entry *properties) 313 { 314 struct property_entry *p; 315 int i, n = 0; 316 int ret; 317 318 if (!properties) 319 return NULL; 320 321 while (properties[n].name) 322 n++; 323 324 p = kcalloc(n + 1, sizeof(*p), GFP_KERNEL); 325 if (!p) 326 return ERR_PTR(-ENOMEM); 327 328 for (i = 0; i < n; i++) { 329 ret = property_entry_copy_data(&p[i], &properties[i]); 330 if (ret) { 331 while (--i >= 0) 332 property_entry_free_data(&p[i]); 333 kfree(p); 334 return ERR_PTR(ret); 335 } 336 } 337 338 return p; 339 } 340 EXPORT_SYMBOL_GPL(property_entries_dup); 341 342 /** 343 * property_entries_free - free previously allocated array of properties 344 * @properties: array of properties to destroy 345 * 346 * This function frees given NULL-terminated array of property entries, 347 * along with their data. 348 */ 349 void property_entries_free(const struct property_entry *properties) 350 { 351 const struct property_entry *p; 352 353 if (!properties) 354 return; 355 356 for (p = properties; p->name; p++) 357 property_entry_free_data(p); 358 359 kfree(properties); 360 } 361 EXPORT_SYMBOL_GPL(property_entries_free); 362 363 /* -------------------------------------------------------------------------- */ 364 /* fwnode operations */ 365 366 static struct fwnode_handle *software_node_get(struct fwnode_handle *fwnode) 367 { 368 struct swnode *swnode = to_swnode(fwnode); 369 370 kobject_get(&swnode->kobj); 371 372 return &swnode->fwnode; 373 } 374 375 static void software_node_put(struct fwnode_handle *fwnode) 376 { 377 struct swnode *swnode = to_swnode(fwnode); 378 379 kobject_put(&swnode->kobj); 380 } 381 382 static bool software_node_property_present(const struct fwnode_handle *fwnode, 383 const char *propname) 384 { 385 struct swnode *swnode = to_swnode(fwnode); 386 387 return !!property_entry_get(swnode->node->properties, propname); 388 } 389 390 static int software_node_read_int_array(const struct fwnode_handle *fwnode, 391 const char *propname, 392 unsigned int elem_size, void *val, 393 size_t nval) 394 { 395 struct swnode *swnode = to_swnode(fwnode); 396 397 return property_entry_read_int_array(swnode->node->properties, propname, 398 elem_size, val, nval); 399 } 400 401 static int software_node_read_string_array(const struct fwnode_handle *fwnode, 402 const char *propname, 403 const char **val, size_t nval) 404 { 405 struct swnode *swnode = to_swnode(fwnode); 406 407 return property_entry_read_string_array(swnode->node->properties, 408 propname, val, nval); 409 } 410 411 static const char * 412 software_node_get_name(const struct fwnode_handle *fwnode) 413 { 414 const struct swnode *swnode = to_swnode(fwnode); 415 416 return kobject_name(&swnode->kobj); 417 } 418 419 static const char * 420 software_node_get_name_prefix(const struct fwnode_handle *fwnode) 421 { 422 struct fwnode_handle *parent; 423 const char *prefix; 424 425 parent = fwnode_get_parent(fwnode); 426 if (!parent) 427 return ""; 428 429 /* Figure out the prefix from the parents. */ 430 while (is_software_node(parent)) 431 parent = fwnode_get_next_parent(parent); 432 433 prefix = fwnode_get_name_prefix(parent); 434 fwnode_handle_put(parent); 435 436 /* Guess something if prefix was NULL. */ 437 return prefix ?: "/"; 438 } 439 440 static struct fwnode_handle * 441 software_node_get_parent(const struct fwnode_handle *fwnode) 442 { 443 struct swnode *swnode = to_swnode(fwnode); 444 445 if (!swnode || !swnode->parent) 446 return NULL; 447 448 return fwnode_handle_get(&swnode->parent->fwnode); 449 } 450 451 static struct fwnode_handle * 452 software_node_get_next_child(const struct fwnode_handle *fwnode, 453 struct fwnode_handle *child) 454 { 455 struct swnode *p = to_swnode(fwnode); 456 struct swnode *c = to_swnode(child); 457 458 if (!p || list_empty(&p->children) || 459 (c && list_is_last(&c->entry, &p->children))) { 460 fwnode_handle_put(child); 461 return NULL; 462 } 463 464 if (c) 465 c = list_next_entry(c, entry); 466 else 467 c = list_first_entry(&p->children, struct swnode, entry); 468 469 fwnode_handle_put(child); 470 return fwnode_handle_get(&c->fwnode); 471 } 472 473 static struct fwnode_handle * 474 software_node_get_named_child_node(const struct fwnode_handle *fwnode, 475 const char *childname) 476 { 477 struct swnode *swnode = to_swnode(fwnode); 478 struct swnode *child; 479 480 if (!swnode || list_empty(&swnode->children)) 481 return NULL; 482 483 list_for_each_entry(child, &swnode->children, entry) { 484 if (!strcmp(childname, kobject_name(&child->kobj))) { 485 kobject_get(&child->kobj); 486 return &child->fwnode; 487 } 488 } 489 return NULL; 490 } 491 492 static int 493 software_node_get_reference_args(const struct fwnode_handle *fwnode, 494 const char *propname, const char *nargs_prop, 495 unsigned int nargs, unsigned int index, 496 struct fwnode_reference_args *args) 497 { 498 struct swnode *swnode = to_swnode(fwnode); 499 const struct software_node_ref_args *ref_array; 500 const struct software_node_ref_args *ref; 501 const struct property_entry *prop; 502 struct fwnode_handle *refnode; 503 u32 nargs_prop_val; 504 int error; 505 int i; 506 507 prop = property_entry_get(swnode->node->properties, propname); 508 if (!prop) 509 return -ENOENT; 510 511 if (prop->type != DEV_PROP_REF) 512 return -EINVAL; 513 514 /* 515 * We expect that references are never stored inline, even 516 * single ones, as they are too big. 517 */ 518 if (prop->is_inline) 519 return -EINVAL; 520 521 if (index * sizeof(*ref) >= prop->length) 522 return -ENOENT; 523 524 ref_array = prop->pointer; 525 ref = &ref_array[index]; 526 527 refnode = software_node_fwnode(ref->node); 528 if (!refnode) 529 return -ENOENT; 530 531 if (nargs_prop) { 532 error = property_entry_read_int_array(ref->node->properties, 533 nargs_prop, sizeof(u32), 534 &nargs_prop_val, 1); 535 if (error) 536 return error; 537 538 nargs = nargs_prop_val; 539 } 540 541 if (nargs > NR_FWNODE_REFERENCE_ARGS) 542 return -EINVAL; 543 544 if (!args) 545 return 0; 546 547 args->fwnode = software_node_get(refnode); 548 args->nargs = nargs; 549 550 for (i = 0; i < nargs; i++) 551 args->args[i] = ref->args[i]; 552 553 return 0; 554 } 555 556 static struct fwnode_handle * 557 swnode_graph_find_next_port(const struct fwnode_handle *parent, 558 struct fwnode_handle *port) 559 { 560 struct fwnode_handle *old = port; 561 562 while ((port = software_node_get_next_child(parent, old))) { 563 /* 564 * fwnode ports have naming style "port@", so we search for any 565 * children that follow that convention. 566 */ 567 if (!strncmp(to_swnode(port)->node->name, "port@", 568 strlen("port@"))) 569 return port; 570 old = port; 571 } 572 573 return NULL; 574 } 575 576 static struct fwnode_handle * 577 software_node_graph_get_next_endpoint(const struct fwnode_handle *fwnode, 578 struct fwnode_handle *endpoint) 579 { 580 struct swnode *swnode = to_swnode(fwnode); 581 struct fwnode_handle *parent; 582 struct fwnode_handle *port; 583 584 if (!swnode) 585 return NULL; 586 587 if (endpoint) { 588 port = software_node_get_parent(endpoint); 589 parent = software_node_get_parent(port); 590 } else { 591 parent = software_node_get_named_child_node(fwnode, "ports"); 592 if (!parent) 593 parent = software_node_get(&swnode->fwnode); 594 595 port = swnode_graph_find_next_port(parent, NULL); 596 } 597 598 for (; port; port = swnode_graph_find_next_port(parent, port)) { 599 endpoint = software_node_get_next_child(port, endpoint); 600 if (endpoint) { 601 fwnode_handle_put(port); 602 break; 603 } 604 } 605 606 fwnode_handle_put(parent); 607 608 return endpoint; 609 } 610 611 static struct fwnode_handle * 612 software_node_graph_get_remote_endpoint(const struct fwnode_handle *fwnode) 613 { 614 struct swnode *swnode = to_swnode(fwnode); 615 const struct software_node_ref_args *ref; 616 const struct property_entry *prop; 617 618 if (!swnode) 619 return NULL; 620 621 prop = property_entry_get(swnode->node->properties, "remote-endpoint"); 622 if (!prop || prop->type != DEV_PROP_REF || prop->is_inline) 623 return NULL; 624 625 ref = prop->pointer; 626 627 return software_node_get(software_node_fwnode(ref[0].node)); 628 } 629 630 static struct fwnode_handle * 631 software_node_graph_get_port_parent(struct fwnode_handle *fwnode) 632 { 633 struct swnode *swnode = to_swnode(fwnode); 634 635 swnode = swnode->parent; 636 if (swnode && !strcmp(swnode->node->name, "ports")) 637 swnode = swnode->parent; 638 639 return swnode ? software_node_get(&swnode->fwnode) : NULL; 640 } 641 642 static int 643 software_node_graph_parse_endpoint(const struct fwnode_handle *fwnode, 644 struct fwnode_endpoint *endpoint) 645 { 646 struct swnode *swnode = to_swnode(fwnode); 647 const char *parent_name = swnode->parent->node->name; 648 int ret; 649 650 if (strlen("port@") >= strlen(parent_name) || 651 strncmp(parent_name, "port@", strlen("port@"))) 652 return -EINVAL; 653 654 /* Ports have naming style "port@n", we need to select the n */ 655 ret = kstrtou32(parent_name + strlen("port@"), 10, &endpoint->port); 656 if (ret) 657 return ret; 658 659 endpoint->id = swnode->id; 660 endpoint->local_fwnode = fwnode; 661 662 return 0; 663 } 664 665 static const struct fwnode_operations software_node_ops = { 666 .get = software_node_get, 667 .put = software_node_put, 668 .property_present = software_node_property_present, 669 .property_read_int_array = software_node_read_int_array, 670 .property_read_string_array = software_node_read_string_array, 671 .get_name = software_node_get_name, 672 .get_name_prefix = software_node_get_name_prefix, 673 .get_parent = software_node_get_parent, 674 .get_next_child_node = software_node_get_next_child, 675 .get_named_child_node = software_node_get_named_child_node, 676 .get_reference_args = software_node_get_reference_args, 677 .graph_get_next_endpoint = software_node_graph_get_next_endpoint, 678 .graph_get_remote_endpoint = software_node_graph_get_remote_endpoint, 679 .graph_get_port_parent = software_node_graph_get_port_parent, 680 .graph_parse_endpoint = software_node_graph_parse_endpoint, 681 }; 682 683 /* -------------------------------------------------------------------------- */ 684 685 /** 686 * software_node_find_by_name - Find software node by name 687 * @parent: Parent of the software node 688 * @name: Name of the software node 689 * 690 * The function will find a node that is child of @parent and that is named 691 * @name. If no node is found, the function returns NULL. 692 * 693 * NOTE: you will need to drop the reference with fwnode_handle_put() after use. 694 */ 695 const struct software_node * 696 software_node_find_by_name(const struct software_node *parent, const char *name) 697 { 698 struct swnode *swnode = NULL; 699 struct kobject *k; 700 701 if (!name) 702 return NULL; 703 704 spin_lock(&swnode_kset->list_lock); 705 706 list_for_each_entry(k, &swnode_kset->list, entry) { 707 swnode = kobj_to_swnode(k); 708 if (parent == swnode->node->parent && swnode->node->name && 709 !strcmp(name, swnode->node->name)) { 710 kobject_get(&swnode->kobj); 711 break; 712 } 713 swnode = NULL; 714 } 715 716 spin_unlock(&swnode_kset->list_lock); 717 718 return swnode ? swnode->node : NULL; 719 } 720 EXPORT_SYMBOL_GPL(software_node_find_by_name); 721 722 static struct software_node *software_node_alloc(const struct property_entry *properties) 723 { 724 struct property_entry *props; 725 struct software_node *node; 726 727 props = property_entries_dup(properties); 728 if (IS_ERR(props)) 729 return ERR_CAST(props); 730 731 node = kzalloc(sizeof(*node), GFP_KERNEL); 732 if (!node) { 733 property_entries_free(props); 734 return ERR_PTR(-ENOMEM); 735 } 736 737 node->properties = props; 738 739 return node; 740 } 741 742 static void software_node_free(const struct software_node *node) 743 { 744 property_entries_free(node->properties); 745 kfree(node); 746 } 747 748 static void software_node_release(struct kobject *kobj) 749 { 750 struct swnode *swnode = kobj_to_swnode(kobj); 751 752 if (swnode->parent) { 753 ida_free(&swnode->parent->child_ids, swnode->id); 754 list_del(&swnode->entry); 755 } else { 756 ida_free(&swnode_root_ids, swnode->id); 757 } 758 759 if (swnode->allocated) 760 software_node_free(swnode->node); 761 762 ida_destroy(&swnode->child_ids); 763 kfree(swnode); 764 } 765 766 static const struct kobj_type software_node_type = { 767 .release = software_node_release, 768 .sysfs_ops = &kobj_sysfs_ops, 769 }; 770 771 static struct fwnode_handle * 772 swnode_register(const struct software_node *node, struct swnode *parent, 773 unsigned int allocated) 774 { 775 struct swnode *swnode; 776 int ret; 777 778 swnode = kzalloc(sizeof(*swnode), GFP_KERNEL); 779 if (!swnode) 780 return ERR_PTR(-ENOMEM); 781 782 ret = ida_alloc(parent ? &parent->child_ids : &swnode_root_ids, 783 GFP_KERNEL); 784 if (ret < 0) { 785 kfree(swnode); 786 return ERR_PTR(ret); 787 } 788 789 swnode->id = ret; 790 swnode->node = node; 791 swnode->parent = parent; 792 swnode->kobj.kset = swnode_kset; 793 fwnode_init(&swnode->fwnode, &software_node_ops); 794 795 ida_init(&swnode->child_ids); 796 INIT_LIST_HEAD(&swnode->entry); 797 INIT_LIST_HEAD(&swnode->children); 798 799 if (node->name) 800 ret = kobject_init_and_add(&swnode->kobj, &software_node_type, 801 parent ? &parent->kobj : NULL, 802 "%s", node->name); 803 else 804 ret = kobject_init_and_add(&swnode->kobj, &software_node_type, 805 parent ? &parent->kobj : NULL, 806 "node%d", swnode->id); 807 if (ret) { 808 kobject_put(&swnode->kobj); 809 return ERR_PTR(ret); 810 } 811 812 /* 813 * Assign the flag only in the successful case, so 814 * the above kobject_put() won't mess up with properties. 815 */ 816 swnode->allocated = allocated; 817 818 if (parent) 819 list_add_tail(&swnode->entry, &parent->children); 820 821 kobject_uevent(&swnode->kobj, KOBJ_ADD); 822 return &swnode->fwnode; 823 } 824 825 /** 826 * software_node_register_node_group - Register a group of software nodes 827 * @node_group: NULL terminated array of software node pointers to be registered 828 * 829 * Register multiple software nodes at once. If any node in the array 830 * has its .parent pointer set (which can only be to another software_node), 831 * then its parent **must** have been registered before it is; either outside 832 * of this function or by ordering the array such that parent comes before 833 * child. 834 */ 835 int software_node_register_node_group(const struct software_node **node_group) 836 { 837 unsigned int i; 838 int ret; 839 840 if (!node_group) 841 return 0; 842 843 for (i = 0; node_group[i]; i++) { 844 ret = software_node_register(node_group[i]); 845 if (ret) { 846 software_node_unregister_node_group(node_group); 847 return ret; 848 } 849 } 850 851 return 0; 852 } 853 EXPORT_SYMBOL_GPL(software_node_register_node_group); 854 855 /** 856 * software_node_unregister_node_group - Unregister a group of software nodes 857 * @node_group: NULL terminated array of software node pointers to be unregistered 858 * 859 * Unregister multiple software nodes at once. If parent pointers are set up 860 * in any of the software nodes then the array **must** be ordered such that 861 * parents come before their children. 862 * 863 * NOTE: If you are uncertain whether the array is ordered such that 864 * parents will be unregistered before their children, it is wiser to 865 * remove the nodes individually, in the correct order (child before 866 * parent). 867 */ 868 void software_node_unregister_node_group( 869 const struct software_node **node_group) 870 { 871 unsigned int i = 0; 872 873 if (!node_group) 874 return; 875 876 while (node_group[i]) 877 i++; 878 879 while (i--) 880 software_node_unregister(node_group[i]); 881 } 882 EXPORT_SYMBOL_GPL(software_node_unregister_node_group); 883 884 /** 885 * software_node_register - Register static software node 886 * @node: The software node to be registered 887 */ 888 int software_node_register(const struct software_node *node) 889 { 890 struct swnode *parent = software_node_to_swnode(node->parent); 891 892 if (software_node_to_swnode(node)) 893 return -EEXIST; 894 895 if (node->parent && !parent) 896 return -EINVAL; 897 898 return PTR_ERR_OR_ZERO(swnode_register(node, parent, 0)); 899 } 900 EXPORT_SYMBOL_GPL(software_node_register); 901 902 /** 903 * software_node_unregister - Unregister static software node 904 * @node: The software node to be unregistered 905 */ 906 void software_node_unregister(const struct software_node *node) 907 { 908 struct swnode *swnode; 909 910 swnode = software_node_to_swnode(node); 911 if (swnode) 912 fwnode_remove_software_node(&swnode->fwnode); 913 } 914 EXPORT_SYMBOL_GPL(software_node_unregister); 915 916 struct fwnode_handle * 917 fwnode_create_software_node(const struct property_entry *properties, 918 const struct fwnode_handle *parent) 919 { 920 struct fwnode_handle *fwnode; 921 struct software_node *node; 922 struct swnode *p; 923 924 if (IS_ERR(parent)) 925 return ERR_CAST(parent); 926 927 p = to_swnode(parent); 928 if (parent && !p) 929 return ERR_PTR(-EINVAL); 930 931 node = software_node_alloc(properties); 932 if (IS_ERR(node)) 933 return ERR_CAST(node); 934 935 node->parent = p ? p->node : NULL; 936 937 fwnode = swnode_register(node, p, 1); 938 if (IS_ERR(fwnode)) 939 software_node_free(node); 940 941 return fwnode; 942 } 943 EXPORT_SYMBOL_GPL(fwnode_create_software_node); 944 945 void fwnode_remove_software_node(struct fwnode_handle *fwnode) 946 { 947 struct swnode *swnode = to_swnode(fwnode); 948 949 if (!swnode) 950 return; 951 952 kobject_put(&swnode->kobj); 953 } 954 EXPORT_SYMBOL_GPL(fwnode_remove_software_node); 955 956 /** 957 * device_add_software_node - Assign software node to a device 958 * @dev: The device the software node is meant for. 959 * @node: The software node. 960 * 961 * This function will make @node the secondary firmware node pointer of @dev. If 962 * @dev has no primary node, then @node will become the primary node. The 963 * function will register @node automatically if it wasn't already registered. 964 */ 965 int device_add_software_node(struct device *dev, const struct software_node *node) 966 { 967 struct swnode *swnode; 968 int ret; 969 970 /* Only one software node per device. */ 971 if (dev_to_swnode(dev)) 972 return -EBUSY; 973 974 swnode = software_node_to_swnode(node); 975 if (swnode) { 976 kobject_get(&swnode->kobj); 977 } else { 978 ret = software_node_register(node); 979 if (ret) 980 return ret; 981 982 swnode = software_node_to_swnode(node); 983 } 984 985 set_secondary_fwnode(dev, &swnode->fwnode); 986 987 /* 988 * If the device has been fully registered by the time this function is 989 * called, software_node_notify() must be called separately so that the 990 * symlinks get created and the reference count of the node is kept in 991 * balance. 992 */ 993 if (device_is_registered(dev)) 994 software_node_notify(dev); 995 996 return 0; 997 } 998 EXPORT_SYMBOL_GPL(device_add_software_node); 999 1000 /** 1001 * device_remove_software_node - Remove device's software node 1002 * @dev: The device with the software node. 1003 * 1004 * This function will unregister the software node of @dev. 1005 */ 1006 void device_remove_software_node(struct device *dev) 1007 { 1008 struct swnode *swnode; 1009 1010 swnode = dev_to_swnode(dev); 1011 if (!swnode) 1012 return; 1013 1014 if (device_is_registered(dev)) 1015 software_node_notify_remove(dev); 1016 1017 set_secondary_fwnode(dev, NULL); 1018 kobject_put(&swnode->kobj); 1019 } 1020 EXPORT_SYMBOL_GPL(device_remove_software_node); 1021 1022 /** 1023 * device_create_managed_software_node - Create a software node for a device 1024 * @dev: The device the software node is assigned to. 1025 * @properties: Device properties for the software node. 1026 * @parent: Parent of the software node. 1027 * 1028 * Creates a software node as a managed resource for @dev, which means the 1029 * lifetime of the newly created software node is tied to the lifetime of @dev. 1030 * Software nodes created with this function should not be reused or shared 1031 * because of that. The function takes a deep copy of @properties for the 1032 * software node. 1033 * 1034 * Since the new software node is assigned directly to @dev, and since it should 1035 * not be shared, it is not returned to the caller. The function returns 0 on 1036 * success, and errno in case of an error. 1037 */ 1038 int device_create_managed_software_node(struct device *dev, 1039 const struct property_entry *properties, 1040 const struct software_node *parent) 1041 { 1042 struct fwnode_handle *p = software_node_fwnode(parent); 1043 struct fwnode_handle *fwnode; 1044 1045 if (parent && !p) 1046 return -EINVAL; 1047 1048 fwnode = fwnode_create_software_node(properties, p); 1049 if (IS_ERR(fwnode)) 1050 return PTR_ERR(fwnode); 1051 1052 to_swnode(fwnode)->managed = true; 1053 set_secondary_fwnode(dev, fwnode); 1054 1055 if (device_is_registered(dev)) 1056 software_node_notify(dev); 1057 1058 return 0; 1059 } 1060 EXPORT_SYMBOL_GPL(device_create_managed_software_node); 1061 1062 void software_node_notify(struct device *dev) 1063 { 1064 struct swnode *swnode; 1065 int ret; 1066 1067 swnode = dev_to_swnode(dev); 1068 if (!swnode) 1069 return; 1070 1071 ret = sysfs_create_link(&dev->kobj, &swnode->kobj, "software_node"); 1072 if (ret) 1073 return; 1074 1075 ret = sysfs_create_link(&swnode->kobj, &dev->kobj, dev_name(dev)); 1076 if (ret) { 1077 sysfs_remove_link(&dev->kobj, "software_node"); 1078 return; 1079 } 1080 1081 kobject_get(&swnode->kobj); 1082 } 1083 1084 void software_node_notify_remove(struct device *dev) 1085 { 1086 struct swnode *swnode; 1087 1088 swnode = dev_to_swnode(dev); 1089 if (!swnode) 1090 return; 1091 1092 sysfs_remove_link(&swnode->kobj, dev_name(dev)); 1093 sysfs_remove_link(&dev->kobj, "software_node"); 1094 kobject_put(&swnode->kobj); 1095 1096 if (swnode->managed) { 1097 set_secondary_fwnode(dev, NULL); 1098 kobject_put(&swnode->kobj); 1099 } 1100 } 1101 1102 static int __init software_node_init(void) 1103 { 1104 swnode_kset = kset_create_and_add("software_nodes", NULL, kernel_kobj); 1105 if (!swnode_kset) 1106 return -ENOMEM; 1107 return 0; 1108 } 1109 postcore_initcall(software_node_init); 1110 1111 static void __exit software_node_exit(void) 1112 { 1113 ida_destroy(&swnode_root_ids); 1114 kset_unregister(swnode_kset); 1115 } 1116 __exitcall(software_node_exit); 1117