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
 14#include <kunit/test.h>
 15#include <kunit/device.h>
 16#include <kunit/resource.h>
 17
 18#include "device-impl.h"
 19
 20/* Wrappers for use with kunit_add_action() */
 21KUNIT_DEFINE_ACTION_WRAPPER(device_unregister_wrapper, device_unregister, struct device *);
 22KUNIT_DEFINE_ACTION_WRAPPER(driver_unregister_wrapper, driver_unregister, struct device_driver *);
 23
 24/* The root device for the KUnit bus, parent of all kunit_devices. */
 25static struct device *kunit_bus_device;
 26
 27/* A device owned by a KUnit test. */
 28struct kunit_device {
 29	struct device dev;
 30	/* The KUnit test which owns this device. */
 31	struct kunit *owner;
 32	/* If the driver is managed by KUnit and unique to this device. */
 33	const struct device_driver *driver;
 34};
 35
 36#define to_kunit_device(d) container_of_const(d, struct kunit_device, dev)
 37
 38static struct bus_type kunit_bus_type = {
 39	.name		= "kunit",
 40};
 41
 42/* Register the 'kunit_bus' used for fake devices. */
 43int kunit_bus_init(void)
 44{
 45	int error;
 46
 47	kunit_bus_device = root_device_register("kunit");
 48	if (IS_ERR(kunit_bus_device))
 49		return PTR_ERR(kunit_bus_device);
 50
 51	error = bus_register(&kunit_bus_type);
 52	if (error)
 53		bus_unregister(&kunit_bus_type);
 54	return error;
 55}
 56
 57/* Unregister the 'kunit_bus' in case the KUnit module is unloaded. */
 58void kunit_bus_shutdown(void)
 59{
 60	/* Make sure the bus exists before we unregister it. */
 61	if (IS_ERR_OR_NULL(kunit_bus_device))
 62		return;
 63
 64	bus_unregister(&kunit_bus_type);
 65
 66	root_device_unregister(kunit_bus_device);
 67
 68	kunit_bus_device = NULL;
 69}
 70
 71/* Release a 'fake' KUnit device. */
 72static void kunit_device_release(struct device *d)
 73{
 74	kfree(to_kunit_device(d));
 75}
 76
 77/*
 78 * Create and register a KUnit-managed struct device_driver on the kunit_bus.
 79 * Returns an error pointer on failure.
 80 */
 81struct device_driver *kunit_driver_create(struct kunit *test, const char *name)
 82{
 83	struct device_driver *driver;
 84	int err = -ENOMEM;
 85
 86	driver = kunit_kzalloc(test, sizeof(*driver), GFP_KERNEL);
 87
 88	if (!driver)
 89		return ERR_PTR(err);
 90
 91	driver->name = name;
 92	driver->bus = &kunit_bus_type;
 93	driver->owner = THIS_MODULE;
 94
 95	err = driver_register(driver);
 96	if (err) {
 97		kunit_kfree(test, driver);
 98		return ERR_PTR(err);
 99	}
100
101	kunit_add_action(test, driver_unregister_wrapper, driver);
102	return driver;
103}
104EXPORT_SYMBOL_GPL(kunit_driver_create);
105
106/* Helper which creates a kunit_device, attaches it to the kunit_bus*/
107static struct kunit_device *kunit_device_register_internal(struct kunit *test,
108							   const char *name,
109							   const struct device_driver *drv)
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_add_action(test, device_unregister_wrapper, &kunit_dev->dev);
137
138	return kunit_dev;
139}
140
141/*
142 * Create and register a new KUnit-managed device, using the user-supplied device_driver.
143 * On failure, returns an error pointer.
144 */
145struct device *kunit_device_register_with_driver(struct kunit *test,
146						 const char *name,
147						 const struct device_driver *drv)
148{
149	struct kunit_device *kunit_dev = kunit_device_register_internal(test, name, drv);
150
151	if (IS_ERR_OR_NULL(kunit_dev))
152		return ERR_CAST(kunit_dev);
153
154	return &kunit_dev->dev;
155}
156EXPORT_SYMBOL_GPL(kunit_device_register_with_driver);
157
158/*
159 * Create and register a new KUnit-managed device, including a matching device_driver.
160 * On failure, returns an error pointer.
161 */
162struct device *kunit_device_register(struct kunit *test, const char *name)
163{
164	struct device_driver *drv;
165	struct kunit_device *dev;
166
167	drv = kunit_driver_create(test, name);
168	if (IS_ERR(drv))
169		return ERR_CAST(drv);
170
171	dev = kunit_device_register_internal(test, name, drv);
172	if (IS_ERR(dev)) {
173		kunit_release_action(test, driver_unregister_wrapper, (void *)drv);
174		return ERR_CAST(dev);
175	}
176
177	/* Request the driver be freed. */
178	dev->driver = drv;
179
180
181	return &dev->dev;
182}
183EXPORT_SYMBOL_GPL(kunit_device_register);
184
185/* Unregisters a KUnit-managed device early (including the driver, if automatically created). */
186void kunit_device_unregister(struct kunit *test, struct device *dev)
187{
188	const struct device_driver *driver = to_kunit_device(dev)->driver;
189
190	kunit_release_action(test, device_unregister_wrapper, dev);
191	if (driver)
192		kunit_release_action(test, driver_unregister_wrapper, (void *)driver);
193}
194EXPORT_SYMBOL_GPL(kunit_device_unregister);
195