1989d42e8SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
279543cf2SDmitry Torokhov /*
379543cf2SDmitry Torokhov * Copyright (C) 2014 Google, Inc.
479543cf2SDmitry Torokhov */
579543cf2SDmitry Torokhov
679543cf2SDmitry Torokhov #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
779543cf2SDmitry Torokhov
879543cf2SDmitry Torokhov #include <linux/delay.h>
979543cf2SDmitry Torokhov #include <linux/init.h>
1079543cf2SDmitry Torokhov #include <linux/hrtimer.h>
1179543cf2SDmitry Torokhov #include <linux/module.h>
1279543cf2SDmitry Torokhov #include <linux/platform_device.h>
1379543cf2SDmitry Torokhov #include <linux/time.h>
1457ea974fSAlexander Duyck #include <linux/numa.h>
1557ea974fSAlexander Duyck #include <linux/nodemask.h>
1657ea974fSAlexander Duyck #include <linux/topology.h>
1779543cf2SDmitry Torokhov
1879543cf2SDmitry Torokhov #define TEST_PROBE_DELAY (5 * 1000) /* 5 sec */
1979543cf2SDmitry Torokhov #define TEST_PROBE_THRESHOLD (TEST_PROBE_DELAY / 2)
2079543cf2SDmitry Torokhov
2157ea974fSAlexander Duyck static atomic_t warnings, errors, timeout, async_completed;
2257ea974fSAlexander Duyck
test_probe(struct platform_device * pdev)2379543cf2SDmitry Torokhov static int test_probe(struct platform_device *pdev)
2479543cf2SDmitry Torokhov {
2557ea974fSAlexander Duyck struct device *dev = &pdev->dev;
2657ea974fSAlexander Duyck
2757ea974fSAlexander Duyck /*
2857ea974fSAlexander Duyck * Determine if we have hit the "timeout" limit for the test if we
2957ea974fSAlexander Duyck * have then report it as an error, otherwise we wil sleep for the
3057ea974fSAlexander Duyck * required amount of time and then report completion.
3157ea974fSAlexander Duyck */
3257ea974fSAlexander Duyck if (atomic_read(&timeout)) {
3357ea974fSAlexander Duyck dev_err(dev, "async probe took too long\n");
3457ea974fSAlexander Duyck atomic_inc(&errors);
3557ea974fSAlexander Duyck } else {
3657ea974fSAlexander Duyck dev_dbg(&pdev->dev, "sleeping for %d msecs in probe\n",
3779543cf2SDmitry Torokhov TEST_PROBE_DELAY);
3879543cf2SDmitry Torokhov msleep(TEST_PROBE_DELAY);
3957ea974fSAlexander Duyck dev_dbg(&pdev->dev, "done sleeping\n");
4057ea974fSAlexander Duyck }
4157ea974fSAlexander Duyck
4257ea974fSAlexander Duyck /*
4357ea974fSAlexander Duyck * Report NUMA mismatch if device node is set and we are not
4457ea974fSAlexander Duyck * performing an async init on that node.
4557ea974fSAlexander Duyck */
4657ea974fSAlexander Duyck if (dev->driver->probe_type == PROBE_PREFER_ASYNCHRONOUS) {
47264d2527SGuenter Roeck if (IS_ENABLED(CONFIG_NUMA) &&
48264d2527SGuenter Roeck dev_to_node(dev) != numa_node_id()) {
4957ea974fSAlexander Duyck dev_warn(dev, "NUMA node mismatch %d != %d\n",
5057ea974fSAlexander Duyck dev_to_node(dev), numa_node_id());
5157ea974fSAlexander Duyck atomic_inc(&warnings);
5257ea974fSAlexander Duyck }
5357ea974fSAlexander Duyck
5457ea974fSAlexander Duyck atomic_inc(&async_completed);
5557ea974fSAlexander Duyck }
5679543cf2SDmitry Torokhov
5779543cf2SDmitry Torokhov return 0;
5879543cf2SDmitry Torokhov }
5979543cf2SDmitry Torokhov
6079543cf2SDmitry Torokhov static struct platform_driver async_driver = {
6179543cf2SDmitry Torokhov .driver = {
6279543cf2SDmitry Torokhov .name = "test_async_driver",
6379543cf2SDmitry Torokhov .probe_type = PROBE_PREFER_ASYNCHRONOUS,
6479543cf2SDmitry Torokhov },
6579543cf2SDmitry Torokhov .probe = test_probe,
6679543cf2SDmitry Torokhov };
6779543cf2SDmitry Torokhov
6879543cf2SDmitry Torokhov static struct platform_driver sync_driver = {
6979543cf2SDmitry Torokhov .driver = {
7079543cf2SDmitry Torokhov .name = "test_sync_driver",
7179543cf2SDmitry Torokhov .probe_type = PROBE_FORCE_SYNCHRONOUS,
7279543cf2SDmitry Torokhov },
7379543cf2SDmitry Torokhov .probe = test_probe,
7479543cf2SDmitry Torokhov };
7579543cf2SDmitry Torokhov
7657ea974fSAlexander Duyck static struct platform_device *async_dev[NR_CPUS * 2];
7757ea974fSAlexander Duyck static struct platform_device *sync_dev[2];
7857ea974fSAlexander Duyck
7957ea974fSAlexander Duyck static struct platform_device *
test_platform_device_register_node(char * name,int id,int nid)8057ea974fSAlexander Duyck test_platform_device_register_node(char *name, int id, int nid)
8157ea974fSAlexander Duyck {
8257ea974fSAlexander Duyck struct platform_device *pdev;
8357ea974fSAlexander Duyck int ret;
8457ea974fSAlexander Duyck
8557ea974fSAlexander Duyck pdev = platform_device_alloc(name, id);
8657ea974fSAlexander Duyck if (!pdev)
87*22d2381bSDan Carpenter return ERR_PTR(-ENOMEM);
8857ea974fSAlexander Duyck
8957ea974fSAlexander Duyck if (nid != NUMA_NO_NODE)
9057ea974fSAlexander Duyck set_dev_node(&pdev->dev, nid);
9157ea974fSAlexander Duyck
9257ea974fSAlexander Duyck ret = platform_device_add(pdev);
9357ea974fSAlexander Duyck if (ret) {
9457ea974fSAlexander Duyck platform_device_put(pdev);
9557ea974fSAlexander Duyck return ERR_PTR(ret);
9657ea974fSAlexander Duyck }
9757ea974fSAlexander Duyck
9857ea974fSAlexander Duyck return pdev;
9957ea974fSAlexander Duyck
10057ea974fSAlexander Duyck }
10179543cf2SDmitry Torokhov
test_async_probe_init(void)10279543cf2SDmitry Torokhov static int __init test_async_probe_init(void)
10379543cf2SDmitry Torokhov {
10457ea974fSAlexander Duyck struct platform_device **pdev = NULL;
10557ea974fSAlexander Duyck int async_id = 0, sync_id = 0;
10679543cf2SDmitry Torokhov unsigned long long duration;
10767aa58e8SMark-PK Tsai ktime_t calltime;
10857ea974fSAlexander Duyck int err, nid, cpu;
10979543cf2SDmitry Torokhov
11057ea974fSAlexander Duyck pr_info("registering first set of asynchronous devices...\n");
11179543cf2SDmitry Torokhov
11257ea974fSAlexander Duyck for_each_online_cpu(cpu) {
11357ea974fSAlexander Duyck nid = cpu_to_node(cpu);
11457ea974fSAlexander Duyck pdev = &async_dev[async_id];
11557ea974fSAlexander Duyck *pdev = test_platform_device_register_node("test_async_driver",
11657ea974fSAlexander Duyck async_id,
11757ea974fSAlexander Duyck nid);
11857ea974fSAlexander Duyck if (IS_ERR(*pdev)) {
11957ea974fSAlexander Duyck err = PTR_ERR(*pdev);
12057ea974fSAlexander Duyck *pdev = NULL;
12157ea974fSAlexander Duyck pr_err("failed to create async_dev: %d\n", err);
12257ea974fSAlexander Duyck goto err_unregister_async_devs;
12357ea974fSAlexander Duyck }
12457ea974fSAlexander Duyck
12557ea974fSAlexander Duyck async_id++;
12679543cf2SDmitry Torokhov }
12779543cf2SDmitry Torokhov
12879543cf2SDmitry Torokhov pr_info("registering asynchronous driver...\n");
12979543cf2SDmitry Torokhov calltime = ktime_get();
13057ea974fSAlexander Duyck err = platform_driver_register(&async_driver);
13157ea974fSAlexander Duyck if (err) {
13257ea974fSAlexander Duyck pr_err("Failed to register async_driver: %d\n", err);
13357ea974fSAlexander Duyck goto err_unregister_async_devs;
13479543cf2SDmitry Torokhov }
13579543cf2SDmitry Torokhov
13667aa58e8SMark-PK Tsai duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
13779543cf2SDmitry Torokhov pr_info("registration took %lld msecs\n", duration);
13879543cf2SDmitry Torokhov if (duration > TEST_PROBE_THRESHOLD) {
13979543cf2SDmitry Torokhov pr_err("test failed: probe took too long\n");
14057ea974fSAlexander Duyck err = -ETIMEDOUT;
14179543cf2SDmitry Torokhov goto err_unregister_async_driver;
14279543cf2SDmitry Torokhov }
14379543cf2SDmitry Torokhov
14457ea974fSAlexander Duyck pr_info("registering second set of asynchronous devices...\n");
14579543cf2SDmitry Torokhov calltime = ktime_get();
14657ea974fSAlexander Duyck for_each_online_cpu(cpu) {
14757ea974fSAlexander Duyck nid = cpu_to_node(cpu);
1489be182daSChen Zhongjin pdev = &async_dev[async_id];
14957ea974fSAlexander Duyck
15057ea974fSAlexander Duyck *pdev = test_platform_device_register_node("test_async_driver",
15157ea974fSAlexander Duyck async_id,
15257ea974fSAlexander Duyck nid);
15357ea974fSAlexander Duyck if (IS_ERR(*pdev)) {
15457ea974fSAlexander Duyck err = PTR_ERR(*pdev);
15557ea974fSAlexander Duyck *pdev = NULL;
15657ea974fSAlexander Duyck pr_err("failed to create async_dev: %d\n", err);
15779543cf2SDmitry Torokhov goto err_unregister_async_driver;
15879543cf2SDmitry Torokhov }
15979543cf2SDmitry Torokhov
16057ea974fSAlexander Duyck async_id++;
16157ea974fSAlexander Duyck }
16257ea974fSAlexander Duyck
16367aa58e8SMark-PK Tsai duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
16457ea974fSAlexander Duyck dev_info(&(*pdev)->dev,
16557ea974fSAlexander Duyck "registration took %lld msecs\n", duration);
16679543cf2SDmitry Torokhov if (duration > TEST_PROBE_THRESHOLD) {
16757ea974fSAlexander Duyck dev_err(&(*pdev)->dev,
16857ea974fSAlexander Duyck "test failed: probe took too long\n");
16957ea974fSAlexander Duyck err = -ETIMEDOUT;
17057ea974fSAlexander Duyck goto err_unregister_async_driver;
17179543cf2SDmitry Torokhov }
17279543cf2SDmitry Torokhov
17357ea974fSAlexander Duyck
17457ea974fSAlexander Duyck pr_info("registering first synchronous device...\n");
17557ea974fSAlexander Duyck nid = cpu_to_node(cpu);
17657ea974fSAlexander Duyck pdev = &sync_dev[sync_id];
17757ea974fSAlexander Duyck
17857ea974fSAlexander Duyck *pdev = test_platform_device_register_node("test_sync_driver",
17957ea974fSAlexander Duyck sync_id,
18057ea974fSAlexander Duyck NUMA_NO_NODE);
18157ea974fSAlexander Duyck if (IS_ERR(*pdev)) {
18257ea974fSAlexander Duyck err = PTR_ERR(*pdev);
18357ea974fSAlexander Duyck *pdev = NULL;
18457ea974fSAlexander Duyck pr_err("failed to create sync_dev: %d\n", err);
18557ea974fSAlexander Duyck goto err_unregister_async_driver;
18657ea974fSAlexander Duyck }
18757ea974fSAlexander Duyck
18857ea974fSAlexander Duyck sync_id++;
18957ea974fSAlexander Duyck
19079543cf2SDmitry Torokhov pr_info("registering synchronous driver...\n");
19179543cf2SDmitry Torokhov calltime = ktime_get();
19257ea974fSAlexander Duyck err = platform_driver_register(&sync_driver);
19357ea974fSAlexander Duyck if (err) {
19457ea974fSAlexander Duyck pr_err("Failed to register async_driver: %d\n", err);
19557ea974fSAlexander Duyck goto err_unregister_sync_devs;
19679543cf2SDmitry Torokhov }
19779543cf2SDmitry Torokhov
19867aa58e8SMark-PK Tsai duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
19979543cf2SDmitry Torokhov pr_info("registration took %lld msecs\n", duration);
20079543cf2SDmitry Torokhov if (duration < TEST_PROBE_THRESHOLD) {
20157ea974fSAlexander Duyck dev_err(&(*pdev)->dev,
20257ea974fSAlexander Duyck "test failed: probe was too quick\n");
20357ea974fSAlexander Duyck err = -ETIMEDOUT;
20457ea974fSAlexander Duyck goto err_unregister_sync_driver;
20579543cf2SDmitry Torokhov }
20679543cf2SDmitry Torokhov
20757ea974fSAlexander Duyck pr_info("registering second synchronous device...\n");
20857ea974fSAlexander Duyck pdev = &sync_dev[sync_id];
20957ea974fSAlexander Duyck calltime = ktime_get();
21079543cf2SDmitry Torokhov
21157ea974fSAlexander Duyck *pdev = test_platform_device_register_node("test_sync_driver",
21257ea974fSAlexander Duyck sync_id,
21357ea974fSAlexander Duyck NUMA_NO_NODE);
21457ea974fSAlexander Duyck if (IS_ERR(*pdev)) {
21557ea974fSAlexander Duyck err = PTR_ERR(*pdev);
21657ea974fSAlexander Duyck *pdev = NULL;
21757ea974fSAlexander Duyck pr_err("failed to create sync_dev: %d\n", err);
21857ea974fSAlexander Duyck goto err_unregister_sync_driver;
21957ea974fSAlexander Duyck }
22057ea974fSAlexander Duyck
22157ea974fSAlexander Duyck sync_id++;
22257ea974fSAlexander Duyck
22367aa58e8SMark-PK Tsai duration = (unsigned long long)ktime_ms_delta(ktime_get(), calltime);
22457ea974fSAlexander Duyck dev_info(&(*pdev)->dev,
22557ea974fSAlexander Duyck "registration took %lld msecs\n", duration);
22657ea974fSAlexander Duyck if (duration < TEST_PROBE_THRESHOLD) {
22757ea974fSAlexander Duyck dev_err(&(*pdev)->dev,
22857ea974fSAlexander Duyck "test failed: probe was too quick\n");
22957ea974fSAlexander Duyck err = -ETIMEDOUT;
23057ea974fSAlexander Duyck goto err_unregister_sync_driver;
23157ea974fSAlexander Duyck }
23257ea974fSAlexander Duyck
23357ea974fSAlexander Duyck /*
23457ea974fSAlexander Duyck * The async events should have completed while we were taking care
23557ea974fSAlexander Duyck * of the synchronous events. We will now terminate any outstanding
23657ea974fSAlexander Duyck * asynchronous probe calls remaining by forcing timeout and remove
23757ea974fSAlexander Duyck * the driver before we return which should force the flush of the
23857ea974fSAlexander Duyck * pending asynchronous probe calls.
23957ea974fSAlexander Duyck *
24057ea974fSAlexander Duyck * Otherwise if they completed without errors or warnings then
24157ea974fSAlexander Duyck * report successful completion.
24257ea974fSAlexander Duyck */
24357ea974fSAlexander Duyck if (atomic_read(&async_completed) != async_id) {
24457ea974fSAlexander Duyck pr_err("async events still pending, forcing timeout\n");
24557ea974fSAlexander Duyck atomic_inc(&timeout);
24657ea974fSAlexander Duyck err = -ETIMEDOUT;
24757ea974fSAlexander Duyck } else if (!atomic_read(&errors) && !atomic_read(&warnings)) {
24857ea974fSAlexander Duyck pr_info("completed successfully\n");
24979543cf2SDmitry Torokhov return 0;
25057ea974fSAlexander Duyck }
25179543cf2SDmitry Torokhov
25279543cf2SDmitry Torokhov err_unregister_sync_driver:
25379543cf2SDmitry Torokhov platform_driver_unregister(&sync_driver);
25457ea974fSAlexander Duyck err_unregister_sync_devs:
25557ea974fSAlexander Duyck while (sync_id--)
25657ea974fSAlexander Duyck platform_device_unregister(sync_dev[sync_id]);
25779543cf2SDmitry Torokhov err_unregister_async_driver:
25879543cf2SDmitry Torokhov platform_driver_unregister(&async_driver);
25957ea974fSAlexander Duyck err_unregister_async_devs:
26057ea974fSAlexander Duyck while (async_id--)
26157ea974fSAlexander Duyck platform_device_unregister(async_dev[async_id]);
26279543cf2SDmitry Torokhov
26357ea974fSAlexander Duyck /*
26457ea974fSAlexander Duyck * If err is already set then count that as an additional error for
26557ea974fSAlexander Duyck * the test. Otherwise we will report an invalid argument error and
26657ea974fSAlexander Duyck * not count that as we should have reached here as a result of
26757ea974fSAlexander Duyck * errors or warnings being reported by the probe routine.
26857ea974fSAlexander Duyck */
26957ea974fSAlexander Duyck if (err)
27057ea974fSAlexander Duyck atomic_inc(&errors);
27157ea974fSAlexander Duyck else
27257ea974fSAlexander Duyck err = -EINVAL;
27379543cf2SDmitry Torokhov
27457ea974fSAlexander Duyck pr_err("Test failed with %d errors and %d warnings\n",
27557ea974fSAlexander Duyck atomic_read(&errors), atomic_read(&warnings));
27657ea974fSAlexander Duyck
27757ea974fSAlexander Duyck return err;
27879543cf2SDmitry Torokhov }
27979543cf2SDmitry Torokhov module_init(test_async_probe_init);
28079543cf2SDmitry Torokhov
test_async_probe_exit(void)28179543cf2SDmitry Torokhov static void __exit test_async_probe_exit(void)
28279543cf2SDmitry Torokhov {
28357ea974fSAlexander Duyck int id = 2;
28457ea974fSAlexander Duyck
28579543cf2SDmitry Torokhov platform_driver_unregister(&async_driver);
28679543cf2SDmitry Torokhov platform_driver_unregister(&sync_driver);
28757ea974fSAlexander Duyck
28857ea974fSAlexander Duyck while (id--)
28957ea974fSAlexander Duyck platform_device_unregister(sync_dev[id]);
29057ea974fSAlexander Duyck
29157ea974fSAlexander Duyck id = NR_CPUS * 2;
29257ea974fSAlexander Duyck while (id--)
29357ea974fSAlexander Duyck platform_device_unregister(async_dev[id]);
29479543cf2SDmitry Torokhov }
29579543cf2SDmitry Torokhov module_exit(test_async_probe_exit);
29679543cf2SDmitry Torokhov
29779543cf2SDmitry Torokhov MODULE_DESCRIPTION("Test module for asynchronous driver probing");
29879543cf2SDmitry Torokhov MODULE_AUTHOR("Dmitry Torokhov <dtor@chromium.org>");
29979543cf2SDmitry Torokhov MODULE_LICENSE("GPL");
300