1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
|
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* Common code for drivers creating fake platform devices.
*
* Provides synchronous device creation: waits for probe completion and
* returns the probe success or error status to the device creator.
*
* Copyright (C) 2021 Bartosz Golaszewski <brgl@bgdev.pl>
* Copyright (C) 2025 Koichiro Den <koichiro.den@canonical.com>
*/
#include <linux/device.h>
#include <linux/slab.h>
#include "dev-sync-probe.h"
static int dev_sync_probe_notifier_call(struct notifier_block *nb,
unsigned long action, void *data)
{
struct dev_sync_probe_data *pdata;
struct device *dev = data;
pdata = container_of(nb, struct dev_sync_probe_data, bus_notifier);
if (!device_match_name(dev, pdata->name))
return NOTIFY_DONE;
switch (action) {
case BUS_NOTIFY_BOUND_DRIVER:
pdata->driver_bound = true;
break;
case BUS_NOTIFY_DRIVER_NOT_BOUND:
pdata->driver_bound = false;
break;
default:
return NOTIFY_DONE;
}
complete(&pdata->probe_completion);
return NOTIFY_OK;
}
void dev_sync_probe_init(struct dev_sync_probe_data *data)
{
memset(data, 0, sizeof(*data));
init_completion(&data->probe_completion);
data->bus_notifier.notifier_call = dev_sync_probe_notifier_call;
}
EXPORT_SYMBOL_GPL(dev_sync_probe_init);
int dev_sync_probe_register(struct dev_sync_probe_data *data,
struct platform_device_info *pdevinfo)
{
struct platform_device *pdev;
char *name;
name = kasprintf(GFP_KERNEL, "%s.%d", pdevinfo->name, pdevinfo->id);
if (!name)
return -ENOMEM;
data->driver_bound = false;
data->name = name;
reinit_completion(&data->probe_completion);
bus_register_notifier(&platform_bus_type, &data->bus_notifier);
pdev = platform_device_register_full(pdevinfo);
if (IS_ERR(pdev)) {
bus_unregister_notifier(&platform_bus_type, &data->bus_notifier);
kfree(data->name);
return PTR_ERR(pdev);
}
wait_for_completion(&data->probe_completion);
bus_unregister_notifier(&platform_bus_type, &data->bus_notifier);
if (!data->driver_bound) {
platform_device_unregister(pdev);
kfree(data->name);
return -ENXIO;
}
data->pdev = pdev;
return 0;
}
EXPORT_SYMBOL_GPL(dev_sync_probe_register);
void dev_sync_probe_unregister(struct dev_sync_probe_data *data)
{
platform_device_unregister(data->pdev);
kfree(data->name);
data->pdev = NULL;
}
EXPORT_SYMBOL_GPL(dev_sync_probe_unregister);
MODULE_AUTHOR("Bartosz Golaszewski <brgl@bgdev.pl>");
MODULE_AUTHOR("Koichiro Den <koichiro.den@canonical.com>");
MODULE_DESCRIPTION("Utilities for synchronous fake device creation");
MODULE_LICENSE("GPL");
|
