1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * KUnit-managed device implementation
4 *
5 * Implementation of struct kunit_device helpers for fake devices whose
6 * lifecycle is managed by KUnit.
7 *
8 * Copyright (C) 2023, Google LLC.
9 * Author: David Gow <davidgow@google.com>
10 */
11
12 #include <linux/device.h>
13 #include <linux/dma-mapping.h>
14
15 #include <kunit/test.h>
16 #include <kunit/device.h>
17 #include <kunit/resource.h>
18
19 #include "device-impl.h"
20
21 /* Wrappers for use with kunit_add_action() */
22 KUNIT_DEFINE_ACTION_WRAPPER(device_unregister_wrapper, device_unregister, struct device *);
23 KUNIT_DEFINE_ACTION_WRAPPER(driver_unregister_wrapper, driver_unregister, struct device_driver *);
24
25 /* The root device for the KUnit bus, parent of all kunit_devices. */
26 static struct device *kunit_bus_device;
27
28 /* A device owned by a KUnit test. */
29 struct kunit_device {
30 struct device dev;
31 /* The KUnit test which owns this device. */
32 struct kunit *owner;
33 /* If the driver is managed by KUnit and unique to this device. */
34 const struct device_driver *driver;
35 };
36
37 #define to_kunit_device(d) container_of_const(d, struct kunit_device, dev)
38
39 static const struct bus_type kunit_bus_type = {
40 .name = "kunit",
41 };
42
43 /* Register the 'kunit_bus' used for fake devices. */
kunit_bus_init(void)44 int kunit_bus_init(void)
45 {
46 int error;
47
48 kunit_bus_device = root_device_register("kunit");
49 if (IS_ERR(kunit_bus_device))
50 return PTR_ERR(kunit_bus_device);
51
52 error = bus_register(&kunit_bus_type);
53 if (error)
54 root_device_unregister(kunit_bus_device);
55 return error;
56 }
57
58 /* Unregister the 'kunit_bus' in case the KUnit module is unloaded. */
kunit_bus_shutdown(void)59 void kunit_bus_shutdown(void)
60 {
61 /* Make sure the bus exists before we unregister it. */
62 if (IS_ERR_OR_NULL(kunit_bus_device))
63 return;
64
65 bus_unregister(&kunit_bus_type);
66
67 root_device_unregister(kunit_bus_device);
68
69 kunit_bus_device = NULL;
70 }
71
72 /* Release a 'fake' KUnit device. */
kunit_device_release(struct device * d)73 static void kunit_device_release(struct device *d)
74 {
75 kfree(to_kunit_device(d));
76 }
77
78 /*
79 * Create and register a KUnit-managed struct device_driver on the kunit_bus.
80 * Returns an error pointer on failure.
81 */
kunit_driver_create(struct kunit * test,const char * name)82 struct device_driver *kunit_driver_create(struct kunit *test, const char *name)
83 {
84 struct device_driver *driver;
85 int err = -ENOMEM;
86
87 driver = kunit_kzalloc(test, sizeof(*driver), GFP_KERNEL);
88
89 if (!driver)
90 return ERR_PTR(err);
91
92 driver->name = kunit_kstrdup_const(test, name, GFP_KERNEL);
93 driver->bus = &kunit_bus_type;
94 driver->owner = THIS_MODULE;
95
96 err = driver_register(driver);
97 if (err) {
98 kunit_kfree(test, driver);
99 return ERR_PTR(err);
100 }
101
102 kunit_add_action(test, driver_unregister_wrapper, driver);
103 return driver;
104 }
105 EXPORT_SYMBOL_GPL(kunit_driver_create);
106
107 /* Helper which creates a kunit_device, attaches it to the kunit_bus*/
kunit_device_register_internal(struct kunit * test,const char * name)108 static struct kunit_device *kunit_device_register_internal(struct kunit *test,
109 const char *name)
110 {
111 struct kunit_device *kunit_dev;
112 int err = -ENOMEM;
113
114 kunit_dev = kzalloc(sizeof(*kunit_dev), GFP_KERNEL);
115 if (!kunit_dev)
116 return ERR_PTR(err);
117
118 kunit_dev->owner = test;
119
120 err = dev_set_name(&kunit_dev->dev, "%s.%s", test->name, name);
121 if (err) {
122 kfree(kunit_dev);
123 return ERR_PTR(err);
124 }
125
126 kunit_dev->dev.release = kunit_device_release;
127 kunit_dev->dev.bus = &kunit_bus_type;
128 kunit_dev->dev.parent = kunit_bus_device;
129
130 err = device_register(&kunit_dev->dev);
131 if (err) {
132 put_device(&kunit_dev->dev);
133 return ERR_PTR(err);
134 }
135
136 kunit_dev->dev.dma_mask = &kunit_dev->dev.coherent_dma_mask;
137 kunit_dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
138
139 kunit_add_action(test, device_unregister_wrapper, &kunit_dev->dev);
140
141 return kunit_dev;
142 }
143
144 /*
145 * Create and register a new KUnit-managed device, using the user-supplied device_driver.
146 * On failure, returns an error pointer.
147 */
kunit_device_register_with_driver(struct kunit * test,const char * name,const struct device_driver * drv)148 struct device *kunit_device_register_with_driver(struct kunit *test,
149 const char *name,
150 const struct device_driver *drv)
151 {
152 struct kunit_device *kunit_dev = kunit_device_register_internal(test, name);
153
154 if (IS_ERR_OR_NULL(kunit_dev))
155 return ERR_CAST(kunit_dev);
156
157 return &kunit_dev->dev;
158 }
159 EXPORT_SYMBOL_GPL(kunit_device_register_with_driver);
160
161 /*
162 * Create and register a new KUnit-managed device, including a matching device_driver.
163 * On failure, returns an error pointer.
164 */
kunit_device_register(struct kunit * test,const char * name)165 struct device *kunit_device_register(struct kunit *test, const char *name)
166 {
167 struct device_driver *drv;
168 struct kunit_device *dev;
169
170 drv = kunit_driver_create(test, name);
171 if (IS_ERR(drv))
172 return ERR_CAST(drv);
173
174 dev = kunit_device_register_internal(test, name);
175 if (IS_ERR(dev)) {
176 kunit_release_action(test, driver_unregister_wrapper, (void *)drv);
177 return ERR_CAST(dev);
178 }
179
180 /* Request the driver be freed. */
181 dev->driver = drv;
182
183
184 return &dev->dev;
185 }
186 EXPORT_SYMBOL_GPL(kunit_device_register);
187
188 /* Unregisters a KUnit-managed device early (including the driver, if automatically created). */
kunit_device_unregister(struct kunit * test,struct device * dev)189 void kunit_device_unregister(struct kunit *test, struct device *dev)
190 {
191 const struct device_driver *driver = to_kunit_device(dev)->driver;
192
193 kunit_release_action(test, device_unregister_wrapper, dev);
194 if (driver) {
195 const char *driver_name = driver->name;
196 kunit_release_action(test, driver_unregister_wrapper, (void *)driver);
197 kunit_kfree_const(test, driver_name);
198 }
199 }
200 EXPORT_SYMBOL_GPL(kunit_device_unregister);
201
202