projects/linux·blob master · refs

146 lines · 4.1 KiB

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
12KUNIT_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 */
29struct fwnode_handle *
30kunit_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}
48EXPORT_SYMBOL_GPL(kunit_fwnode_create_software_node);
49
50KUNIT_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 */
65struct fwnode_handle *
66kunit_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}
87EXPORT_SYMBOL_GPL(kunit_software_node_register);
88
89KUNIT_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 */
104int 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}
116EXPORT_SYMBOL_GPL(kunit_software_node_register_node_group);
117
118KUNIT_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 */
135int 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}
146EXPORT_SYMBOL_GPL(kunit_device_add_software_node);