1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2014 Google, Inc.
4 */
5
6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8#include <linux/delay.h>
9#include <linux/init.h>
10#include <linux/hrtimer.h>
11#include <linux/module.h>
12#include <linux/platform_device.h>
13#include <linux/time.h>
14#include <linux/numa.h>
15#include <linux/nodemask.h>
16#include <linux/topology.h>
17
18#define TEST_PROBE_DELAY	(5 * 1000)	/* 5 sec */
19#define TEST_PROBE_THRESHOLD	(TEST_PROBE_DELAY / 2)
20
21static atomic_t warnings, errors, timeout, async_completed;
22
23static int test_probe(struct platform_device *pdev)
24{
25	struct device *dev = &pdev->dev;
26
27	/*
28	 * Determine if we have hit the "timeout" limit for the test if we
29	 * have then report it as an error, otherwise we wil sleep for the
30	 * required amount of time and then report completion.
31	 */
32	if (atomic_read(&timeout)) {
33		dev_err(dev, "async probe took too long\n");
34		atomic_inc(&errors);
35	} else {
36		dev_dbg(&pdev->dev, "sleeping for %d msecs in probe\n",
37			 TEST_PROBE_DELAY);
38		msleep(TEST_PROBE_DELAY);
39		dev_dbg(&pdev->dev, "done sleeping\n");
40	}
41
42	/*
43	 * Report NUMA mismatch if device node is set and we are not
44	 * performing an async init on that node.
45	 */
46	if (dev->driver->probe_type == PROBE_PREFER_ASYNCHRONOUS) {
47		if (IS_ENABLED(CONFIG_NUMA) &&
48		    dev_to_node(dev) != numa_node_id()) {
49			dev_warn(dev, "NUMA node mismatch %d != %d\n",
50				 dev_to_node(dev), numa_node_id());
51			atomic_inc(&warnings);
52		}
53
54		atomic_inc(&async_completed);
55	}
56
57	return 0;
58}
59
60static struct platform_driver async_driver = {
61	.driver = {
62		.name = "test_async_driver",
63		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
64	},
65	.probe = test_probe,
66};
67
68static struct platform_driver sync_driver = {
69	.driver = {
70		.name = "test_sync_driver",
71		.probe_type = PROBE_FORCE_SYNCHRONOUS,
72	},
73	.probe = test_probe,
74};
75
76static struct platform_device *async_dev[NR_CPUS * 2];
77static struct platform_device *sync_dev[2];
78
79static struct platform_device *
80test_platform_device_register_node(char *name, int id, int nid)
81{
82	struct platform_device *pdev;
83	int ret;
84
85	pdev = platform_device_alloc(name, id);
86	if (!pdev)
87		return ERR_PTR(-ENOMEM);
88
89	if (nid != NUMA_NO_NODE)
90		set_dev_node(&pdev->dev, nid);
91
92	ret = platform_device_add(pdev);
93	if (ret) {
94		platform_device_put(pdev);
95		return ERR_PTR(ret);
96	}
97
98	return pdev;
99
100}
101
102static int __init test_async_probe_init(void)
103{
104	struct platform_device **pdev = NULL;
105	int async_id = 0, sync_id = 0;
106	unsigned long long duration;
107	ktime_t calltime, delta;
108	int err, nid, cpu;
109
110	pr_info("registering first set of asynchronous devices...\n");
111
112	for_each_online_cpu(cpu) {
113		nid = cpu_to_node(cpu);
114		pdev = &async_dev[async_id];
115		*pdev =	test_platform_device_register_node("test_async_driver",
116							   async_id,
117							   nid);
118		if (IS_ERR(*pdev)) {
119			err = PTR_ERR(*pdev);
120			*pdev = NULL;
121			pr_err("failed to create async_dev: %d\n", err);
122			goto err_unregister_async_devs;
123		}
124
125		async_id++;
126	}
127
128	pr_info("registering asynchronous driver...\n");
129	calltime = ktime_get();
130	err = platform_driver_register(&async_driver);
131	if (err) {
132		pr_err("Failed to register async_driver: %d\n", err);
133		goto err_unregister_async_devs;
134	}
135
136	delta = ktime_sub(ktime_get(), calltime);
137	duration = (unsigned long long) ktime_to_ms(delta);
138	pr_info("registration took %lld msecs\n", duration);
139	if (duration > TEST_PROBE_THRESHOLD) {
140		pr_err("test failed: probe took too long\n");
141		err = -ETIMEDOUT;
142		goto err_unregister_async_driver;
143	}
144
145	pr_info("registering second set of asynchronous devices...\n");
146	calltime = ktime_get();
147	for_each_online_cpu(cpu) {
148		nid = cpu_to_node(cpu);
149		pdev = &async_dev[async_id];
150
151		*pdev = test_platform_device_register_node("test_async_driver",
152							   async_id,
153							   nid);
154		if (IS_ERR(*pdev)) {
155			err = PTR_ERR(*pdev);
156			*pdev = NULL;
157			pr_err("failed to create async_dev: %d\n", err);
158			goto err_unregister_async_driver;
159		}
160
161		async_id++;
162	}
163
164	delta = ktime_sub(ktime_get(), calltime);
165	duration = (unsigned long long) ktime_to_ms(delta);
166	dev_info(&(*pdev)->dev,
167		 "registration took %lld msecs\n", duration);
168	if (duration > TEST_PROBE_THRESHOLD) {
169		dev_err(&(*pdev)->dev,
170			"test failed: probe took too long\n");
171		err = -ETIMEDOUT;
172		goto err_unregister_async_driver;
173	}
174
175
176	pr_info("registering first synchronous device...\n");
177	nid = cpu_to_node(cpu);
178	pdev = &sync_dev[sync_id];
179
180	*pdev = test_platform_device_register_node("test_sync_driver",
181						   sync_id,
182						   NUMA_NO_NODE);
183	if (IS_ERR(*pdev)) {
184		err = PTR_ERR(*pdev);
185		*pdev = NULL;
186		pr_err("failed to create sync_dev: %d\n", err);
187		goto err_unregister_async_driver;
188	}
189
190	sync_id++;
191
192	pr_info("registering synchronous driver...\n");
193	calltime = ktime_get();
194	err = platform_driver_register(&sync_driver);
195	if (err) {
196		pr_err("Failed to register async_driver: %d\n", err);
197		goto err_unregister_sync_devs;
198	}
199
200	delta = ktime_sub(ktime_get(), calltime);
201	duration = (unsigned long long) ktime_to_ms(delta);
202	pr_info("registration took %lld msecs\n", duration);
203	if (duration < TEST_PROBE_THRESHOLD) {
204		dev_err(&(*pdev)->dev,
205			"test failed: probe was too quick\n");
206		err = -ETIMEDOUT;
207		goto err_unregister_sync_driver;
208	}
209
210	pr_info("registering second synchronous device...\n");
211	pdev = &sync_dev[sync_id];
212	calltime = ktime_get();
213
214	*pdev = test_platform_device_register_node("test_sync_driver",
215						   sync_id,
216						   NUMA_NO_NODE);
217	if (IS_ERR(*pdev)) {
218		err = PTR_ERR(*pdev);
219		*pdev = NULL;
220		pr_err("failed to create sync_dev: %d\n", err);
221		goto err_unregister_sync_driver;
222	}
223
224	sync_id++;
225
226	delta = ktime_sub(ktime_get(), calltime);
227	duration = (unsigned long long) ktime_to_ms(delta);
228	dev_info(&(*pdev)->dev,
229		 "registration took %lld msecs\n", duration);
230	if (duration < TEST_PROBE_THRESHOLD) {
231		dev_err(&(*pdev)->dev,
232			"test failed: probe was too quick\n");
233		err = -ETIMEDOUT;
234		goto err_unregister_sync_driver;
235	}
236
237	/*
238	 * The async events should have completed while we were taking care
239	 * of the synchronous events. We will now terminate any outstanding
240	 * asynchronous probe calls remaining by forcing timeout and remove
241	 * the driver before we return which should force the flush of the
242	 * pending asynchronous probe calls.
243	 *
244	 * Otherwise if they completed without errors or warnings then
245	 * report successful completion.
246	 */
247	if (atomic_read(&async_completed) != async_id) {
248		pr_err("async events still pending, forcing timeout\n");
249		atomic_inc(&timeout);
250		err = -ETIMEDOUT;
251	} else if (!atomic_read(&errors) && !atomic_read(&warnings)) {
252		pr_info("completed successfully\n");
253		return 0;
254	}
255
256err_unregister_sync_driver:
257	platform_driver_unregister(&sync_driver);
258err_unregister_sync_devs:
259	while (sync_id--)
260		platform_device_unregister(sync_dev[sync_id]);
261err_unregister_async_driver:
262	platform_driver_unregister(&async_driver);
263err_unregister_async_devs:
264	while (async_id--)
265		platform_device_unregister(async_dev[async_id]);
266
267	/*
268	 * If err is already set then count that as an additional error for
269	 * the test. Otherwise we will report an invalid argument error and
270	 * not count that as we should have reached here as a result of
271	 * errors or warnings being reported by the probe routine.
272	 */
273	if (err)
274		atomic_inc(&errors);
275	else
276		err = -EINVAL;
277
278	pr_err("Test failed with %d errors and %d warnings\n",
279	       atomic_read(&errors), atomic_read(&warnings));
280
281	return err;
282}
283module_init(test_async_probe_init);
284
285static void __exit test_async_probe_exit(void)
286{
287	int id = 2;
288
289	platform_driver_unregister(&async_driver);
290	platform_driver_unregister(&sync_driver);
291
292	while (id--)
293		platform_device_unregister(sync_dev[id]);
294
295	id = NR_CPUS * 2;
296	while (id--)
297		platform_device_unregister(async_dev[id]);
298}
299module_exit(test_async_probe_exit);
300
301MODULE_DESCRIPTION("Test module for asynchronous driver probing");
302MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
303MODULE_LICENSE("GPL");
304