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
 15#define TEST_PROBE_DELAY	(5 * 1000)	/* 5 sec */
 16#define TEST_PROBE_THRESHOLD	(TEST_PROBE_DELAY / 2)
 17
 18static int test_probe(struct platform_device *pdev)
 19{
 20	dev_info(&pdev->dev, "sleeping for %d msecs in probe\n",
 21		 TEST_PROBE_DELAY);
 22	msleep(TEST_PROBE_DELAY);
 23	dev_info(&pdev->dev, "done sleeping\n");
 24
 25	return 0;
 26}
 27
 28static struct platform_driver async_driver = {
 29	.driver = {
 30		.name = "test_async_driver",
 31		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 32	},
 33	.probe = test_probe,
 34};
 35
 36static struct platform_driver sync_driver = {
 37	.driver = {
 38		.name = "test_sync_driver",
 39		.probe_type = PROBE_FORCE_SYNCHRONOUS,
 40	},
 41	.probe = test_probe,
 42};
 43
 44static struct platform_device *async_dev_1, *async_dev_2;
 45static struct platform_device *sync_dev_1;
 46
 47static int __init test_async_probe_init(void)
 48{
 49	ktime_t calltime, delta;
 50	unsigned long long duration;
 51	int error;
 52
 53	pr_info("registering first asynchronous device...\n");
 54
 55	async_dev_1 = platform_device_register_simple("test_async_driver", 1,
 56						      NULL, 0);
 57	if (IS_ERR(async_dev_1)) {
 58		error = PTR_ERR(async_dev_1);
 59		pr_err("failed to create async_dev_1: %d\n", error);
 60		return error;
 61	}
 62
 63	pr_info("registering asynchronous driver...\n");
 64	calltime = ktime_get();
 65	error = platform_driver_register(&async_driver);
 66	if (error) {
 67		pr_err("Failed to register async_driver: %d\n", error);
 68		goto err_unregister_async_dev_1;
 69	}
 70
 71	delta = ktime_sub(ktime_get(), calltime);
 72	duration = (unsigned long long) ktime_to_ms(delta);
 73	pr_info("registration took %lld msecs\n", duration);
 74	if (duration > TEST_PROBE_THRESHOLD) {
 75		pr_err("test failed: probe took too long\n");
 76		error = -ETIMEDOUT;
 77		goto err_unregister_async_driver;
 78	}
 79
 80	pr_info("registering second asynchronous device...\n");
 81	calltime = ktime_get();
 82	async_dev_2 = platform_device_register_simple("test_async_driver", 2,
 83						      NULL, 0);
 84	if (IS_ERR(async_dev_2)) {
 85		error = PTR_ERR(async_dev_2);
 86		pr_err("failed to create async_dev_2: %d\n", error);
 87		goto err_unregister_async_driver;
 88	}
 89
 90	delta = ktime_sub(ktime_get(), calltime);
 91	duration = (unsigned long long) ktime_to_ms(delta);
 92	pr_info("registration took %lld msecs\n", duration);
 93	if (duration > TEST_PROBE_THRESHOLD) {
 94		pr_err("test failed: probe took too long\n");
 95		error = -ETIMEDOUT;
 96		goto err_unregister_async_dev_2;
 97	}
 98
 99	pr_info("registering synchronous driver...\n");
100
101	error = platform_driver_register(&sync_driver);
102	if (error) {
103		pr_err("Failed to register async_driver: %d\n", error);
104		goto err_unregister_async_dev_2;
105	}
106
107	pr_info("registering synchronous device...\n");
108	calltime = ktime_get();
109	sync_dev_1 = platform_device_register_simple("test_sync_driver", 1,
110						     NULL, 0);
111	if (IS_ERR(sync_dev_1)) {
112		error = PTR_ERR(sync_dev_1);
113		pr_err("failed to create sync_dev_1: %d\n", error);
114		goto err_unregister_sync_driver;
115	}
116
117	delta = ktime_sub(ktime_get(), calltime);
118	duration = (unsigned long long) ktime_to_ms(delta);
119	pr_info("registration took %lld msecs\n", duration);
120	if (duration < TEST_PROBE_THRESHOLD) {
121		pr_err("test failed: probe was too quick\n");
122		error = -ETIMEDOUT;
123		goto err_unregister_sync_dev_1;
124	}
125
126	pr_info("completed successfully");
127
128	return 0;
129
130err_unregister_sync_dev_1:
131	platform_device_unregister(sync_dev_1);
132
133err_unregister_sync_driver:
134	platform_driver_unregister(&sync_driver);
135
136err_unregister_async_dev_2:
137	platform_device_unregister(async_dev_2);
138
139err_unregister_async_driver:
140	platform_driver_unregister(&async_driver);
141
142err_unregister_async_dev_1:
143	platform_device_unregister(async_dev_1);
144
145	return error;
146}
147module_init(test_async_probe_init);
148
149static void __exit test_async_probe_exit(void)
150{
151	platform_driver_unregister(&async_driver);
152	platform_driver_unregister(&sync_driver);
153	platform_device_unregister(async_dev_1);
154	platform_device_unregister(async_dev_2);
155	platform_device_unregister(sync_dev_1);
156}
157module_exit(test_async_probe_exit);
158
159MODULE_DESCRIPTION("Test module for asynchronous driver probing");
160MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
161MODULE_LICENSE("GPL");