1 // SPDX-License-Identifier: GPL-2.0
2 
3 #include <kunit/resource.h>
4 
5 #include <linux/device.h>
6 #include <linux/platform_device.h>
7 
8 #define DEVICE_NAME "test"
9 
10 struct test_priv {
11 	bool probe_done;
12 	bool release_done;
13 	wait_queue_head_t probe_wq;
14 	wait_queue_head_t release_wq;
15 	struct device *dev;
16 };
17 
18 static int platform_device_devm_init(struct kunit *test)
19 {
20 	struct test_priv *priv;
21 
22 	priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
23 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
24 	init_waitqueue_head(&priv->probe_wq);
25 	init_waitqueue_head(&priv->release_wq);
26 
27 	test->priv = priv;
28 
29 	return 0;
30 }
31 
32 static void devm_device_action(void *ptr)
33 {
34 	struct test_priv *priv = ptr;
35 
36 	priv->release_done = true;
37 	wake_up_interruptible(&priv->release_wq);
38 }
39 
40 static void devm_put_device_action(void *ptr)
41 {
42 	struct test_priv *priv = ptr;
43 
44 	put_device(priv->dev);
45 	priv->release_done = true;
46 	wake_up_interruptible(&priv->release_wq);
47 }
48 
49 #define RELEASE_TIMEOUT_MS	100
50 
51 /*
52  * Tests that a platform bus, non-probed device will run its
53  * device-managed actions when unregistered.
54  */
55 static void platform_device_devm_register_unregister_test(struct kunit *test)
56 {
57 	struct platform_device *pdev;
58 	struct test_priv *priv = test->priv;
59 	int ret;
60 
61 	pdev = platform_device_alloc(DEVICE_NAME, PLATFORM_DEVID_NONE);
62 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
63 
64 	ret = platform_device_add(pdev);
65 	KUNIT_ASSERT_EQ(test, ret, 0);
66 
67 	priv->dev = &pdev->dev;
68 
69 	ret = devm_add_action_or_reset(priv->dev, devm_device_action, priv);
70 	KUNIT_ASSERT_EQ(test, ret, 0);
71 
72 	platform_device_unregister(pdev);
73 
74 	ret = wait_event_interruptible_timeout(priv->release_wq, priv->release_done,
75 					       msecs_to_jiffies(RELEASE_TIMEOUT_MS));
76 	KUNIT_EXPECT_GT(test, ret, 0);
77 }
78 
79 /*
80  * Tests that a platform bus, non-probed device will run its
81  * device-managed actions when unregistered, even if someone still holds
82  * a reference to it.
83  */
84 static void platform_device_devm_register_get_unregister_with_devm_test(struct kunit *test)
85 {
86 	struct platform_device *pdev;
87 	struct test_priv *priv = test->priv;
88 	int ret;
89 
90 	pdev = platform_device_alloc(DEVICE_NAME, PLATFORM_DEVID_NONE);
91 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
92 
93 	ret = platform_device_add(pdev);
94 	KUNIT_ASSERT_EQ(test, ret, 0);
95 
96 	priv->dev = &pdev->dev;
97 
98 	get_device(priv->dev);
99 
100 	ret = devm_add_action_or_reset(priv->dev, devm_put_device_action, priv);
101 	KUNIT_ASSERT_EQ(test, ret, 0);
102 
103 	platform_device_unregister(pdev);
104 
105 	ret = wait_event_interruptible_timeout(priv->release_wq, priv->release_done,
106 					       msecs_to_jiffies(RELEASE_TIMEOUT_MS));
107 	KUNIT_EXPECT_GT(test, ret, 0);
108 }
109 
110 static int fake_probe(struct platform_device *pdev)
111 {
112 	struct test_priv *priv = platform_get_drvdata(pdev);
113 
114 	priv->probe_done = true;
115 	wake_up_interruptible(&priv->probe_wq);
116 
117 	return 0;
118 }
119 
120 static struct platform_driver fake_driver = {
121 	.probe	= fake_probe,
122 	.driver = {
123 		.name = DEVICE_NAME,
124 	},
125 };
126 
127 /*
128  * Tests that a platform bus, probed device will run its device-managed
129  * actions when unregistered.
130  */
131 static void probed_platform_device_devm_register_unregister_test(struct kunit *test)
132 {
133 	struct platform_device *pdev;
134 	struct test_priv *priv = test->priv;
135 	int ret;
136 
137 	ret = platform_driver_register(&fake_driver);
138 	KUNIT_ASSERT_EQ(test, ret, 0);
139 
140 	pdev = platform_device_alloc(DEVICE_NAME, PLATFORM_DEVID_NONE);
141 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
142 
143 	priv->dev = &pdev->dev;
144 	platform_set_drvdata(pdev, priv);
145 
146 	ret = platform_device_add(pdev);
147 	KUNIT_ASSERT_EQ(test, ret, 0);
148 
149 	ret = wait_event_interruptible_timeout(priv->probe_wq, priv->probe_done,
150 					       msecs_to_jiffies(RELEASE_TIMEOUT_MS));
151 	KUNIT_ASSERT_GT(test, ret, 0);
152 
153 	ret = devm_add_action_or_reset(priv->dev, devm_device_action, priv);
154 	KUNIT_ASSERT_EQ(test, ret, 0);
155 
156 	platform_device_unregister(pdev);
157 
158 	ret = wait_event_interruptible_timeout(priv->release_wq, priv->release_done,
159 					       msecs_to_jiffies(RELEASE_TIMEOUT_MS));
160 	KUNIT_EXPECT_GT(test, ret, 0);
161 
162 	platform_driver_unregister(&fake_driver);
163 }
164 
165 /*
166  * Tests that a platform bus, probed device will run its device-managed
167  * actions when unregistered, even if someone still holds a reference to
168  * it.
169  */
170 static void probed_platform_device_devm_register_get_unregister_with_devm_test(struct kunit *test)
171 {
172 	struct platform_device *pdev;
173 	struct test_priv *priv = test->priv;
174 	int ret;
175 
176 	ret = platform_driver_register(&fake_driver);
177 	KUNIT_ASSERT_EQ(test, ret, 0);
178 
179 	pdev = platform_device_alloc(DEVICE_NAME, PLATFORM_DEVID_NONE);
180 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
181 
182 	priv->dev = &pdev->dev;
183 	platform_set_drvdata(pdev, priv);
184 
185 	ret = platform_device_add(pdev);
186 	KUNIT_ASSERT_EQ(test, ret, 0);
187 
188 	ret = wait_event_interruptible_timeout(priv->probe_wq, priv->probe_done,
189 					       msecs_to_jiffies(RELEASE_TIMEOUT_MS));
190 	KUNIT_ASSERT_GT(test, ret, 0);
191 
192 	get_device(priv->dev);
193 
194 	ret = devm_add_action_or_reset(priv->dev, devm_put_device_action, priv);
195 	KUNIT_ASSERT_EQ(test, ret, 0);
196 
197 	platform_device_unregister(pdev);
198 
199 	ret = wait_event_interruptible_timeout(priv->release_wq, priv->release_done,
200 					       msecs_to_jiffies(RELEASE_TIMEOUT_MS));
201 	KUNIT_EXPECT_GT(test, ret, 0);
202 
203 	platform_driver_unregister(&fake_driver);
204 }
205 
206 static struct kunit_case platform_device_devm_tests[] = {
207 	KUNIT_CASE(platform_device_devm_register_unregister_test),
208 	KUNIT_CASE(platform_device_devm_register_get_unregister_with_devm_test),
209 	KUNIT_CASE(probed_platform_device_devm_register_unregister_test),
210 	KUNIT_CASE(probed_platform_device_devm_register_get_unregister_with_devm_test),
211 	{}
212 };
213 
214 static struct kunit_suite platform_device_devm_test_suite = {
215 	.name = "platform-device-devm",
216 	.init = platform_device_devm_init,
217 	.test_cases = platform_device_devm_tests,
218 };
219 
220 kunit_test_suite(platform_device_devm_test_suite);
221 
222 MODULE_DESCRIPTION("Test module for platform devices");
223 MODULE_AUTHOR("Maxime Ripard <mripard@kernel.org>");
224 MODULE_LICENSE("GPL");
225