1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) Qualcomm Technologies, Inc. and/or its subsidiaries 4 */ 5 6 #include <kunit/fwnode.h> 7 #include <kunit/test.h> 8 9 #include <linux/fwnode.h> 10 #include <linux/property.h> 11 12 KUNIT_DEFINE_ACTION_WRAPPER(fwnode_remove_software_node_wrapper, 13 fwnode_remove_software_node, 14 struct fwnode_handle *); 15 16 /** 17 * kunit_fwnode_create_software_node() - Create a kunit-managed software node 18 * @test: Test context 19 * @properties: Properties to use to create the new software node 20 * @parent: Parent of this software node 21 * 22 * Create a test-managed software node and return its firmware node handle. 23 * The software node is removed after the test case completes. 24 * 25 * Returns: 26 * Firmware node handle of the newly created software node or IS_ERR() on 27 * failure. 28 */ 29 struct fwnode_handle * 30 kunit_fwnode_create_software_node(struct kunit *test, 31 const struct property_entry *properties, 32 const struct fwnode_handle *parent) 33 { 34 struct fwnode_handle *fwnode; 35 int ret; 36 37 fwnode = fwnode_create_software_node(properties, parent); 38 if (IS_ERR(fwnode)) 39 return fwnode; 40 41 ret = kunit_add_action_or_reset(test, fwnode_remove_software_node_wrapper, 42 fwnode); 43 if (ret) 44 return ERR_PTR(ret); 45 46 return fwnode; 47 } 48 EXPORT_SYMBOL_GPL(kunit_fwnode_create_software_node); 49 50 KUNIT_DEFINE_ACTION_WRAPPER(software_node_unregister_wrapper, 51 software_node_unregister, 52 const struct software_node *); 53 54 /** 55 * kunit_software_node_register() - Register a kunit-managed software node 56 * @test: Test context 57 * @swnode: Software node to register 58 * 59 * Register a test-managed software node and return its firmware node handle. 60 * The software node is unregistered after the test case completes. 61 * 62 * Returns: 63 * Firmware node handle of the registered software node or IS_ERR() on failure. 64 */ 65 struct fwnode_handle * 66 kunit_software_node_register(struct kunit *test, 67 const struct software_node *swnode) 68 { 69 struct fwnode_handle *fwnode; 70 int ret; 71 72 ret = software_node_register(swnode); 73 if (ret) 74 return ERR_PTR(ret); 75 76 fwnode = software_node_fwnode(swnode); 77 if (WARN_ON(!fwnode)) 78 return ERR_PTR(-ENOENT); 79 80 ret = kunit_add_action_or_reset(test, software_node_unregister_wrapper, 81 (void *)swnode); 82 if (ret) 83 return ERR_PTR(ret); 84 85 return fwnode; 86 } 87 EXPORT_SYMBOL_GPL(kunit_software_node_register); 88 89 KUNIT_DEFINE_ACTION_WRAPPER(software_node_unregister_node_group_wrapper, 90 software_node_unregister_node_group, 91 const struct software_node *const *); 92 93 /** 94 * kunit_software_node_register_node_group() - Register a kunit-managed software node group 95 * @test: Test context 96 * @nodes: Software node group to register 97 * 98 * Register a test-managed software node group. The nodes are unregistered 99 * after the test case completes. 100 * 101 * Returns: 102 * 0 on success, negative error number on failure. 103 */ 104 int kunit_software_node_register_node_group(struct kunit *test, 105 const struct software_node *const *nodes) 106 { 107 int ret; 108 109 ret = software_node_register_node_group(nodes); 110 if (ret) 111 return ret; 112 113 return kunit_add_action_or_reset(test, software_node_unregister_node_group_wrapper, 114 (void *)nodes); 115 } 116 EXPORT_SYMBOL_GPL(kunit_software_node_register_node_group); 117 118 KUNIT_DEFINE_ACTION_WRAPPER(device_remove_software_node_wrapper, 119 device_remove_software_node, 120 struct device *); 121 122 /** 123 * kunit_device_add_software_node() - Assign a kunit-managed software node to a device 124 * @test: Test context 125 * @dev: Device to assign the software node for 126 * @node: The software node to assign 127 * 128 * Make @node the secondary firmware node of @dev. If @dev has no primary 129 * firmware node, @node will become the primary node. The software node will 130 * be automatically removed from @dev when the test case completes. 131 * 132 * Returns: 133 * 0 on success, negative error number on failure. 134 */ 135 int kunit_device_add_software_node(struct kunit *test, struct device *dev, 136 const struct software_node *node) 137 { 138 int ret; 139 140 ret = device_add_software_node(dev, node); 141 if (ret) 142 return ret; 143 144 return kunit_add_action_or_reset(test, device_remove_software_node_wrapper, dev); 145 } 146 EXPORT_SYMBOL_GPL(kunit_device_add_software_node); 147