1// SPDX-License-Identifier: GPL-2.0
  2
  3#include <drm/drm_drv.h>
  4#include <drm/drm_kunit_helpers.h>
  5#include <drm/drm_managed.h>
  6
  7#include <kunit/resource.h>
  8
  9#include <linux/device.h>
 10
 11/* Ought to be enough for anybody */
 12#define TEST_TIMEOUT_MS	100
 13
 14struct managed_test_priv {
 15	struct drm_device *drm;
 16	bool action_done;
 17	wait_queue_head_t action_wq;
 18};
 19
 20static void drm_action(struct drm_device *drm, void *ptr)
 21{
 22	struct managed_test_priv *priv = ptr;
 23
 24	priv->action_done = true;
 25	wake_up_interruptible(&priv->action_wq);
 26}
 27
 28/*
 29 * The test verifies that the release action is called when
 30 * drmm_release_action is called.
 31 */
 32static void drm_test_managed_release_action(struct kunit *test)
 33{
 34	struct managed_test_priv *priv = test->priv;
 35	int ret;
 36
 37	ret = drmm_add_action_or_reset(priv->drm, drm_action, priv);
 38	KUNIT_EXPECT_EQ(test, ret, 0);
 39
 40	ret = drm_dev_register(priv->drm, 0);
 41	KUNIT_ASSERT_EQ(test, ret, 0);
 42
 43	drmm_release_action(priv->drm, drm_action, priv);
 44	ret = wait_event_interruptible_timeout(priv->action_wq, priv->action_done,
 45					       msecs_to_jiffies(TEST_TIMEOUT_MS));
 46	KUNIT_EXPECT_GT(test, ret, 0);
 47
 48	drm_dev_unregister(priv->drm);
 49	drm_kunit_helper_free_device(test, priv->drm->dev);
 50}
 51
 52/*
 53 * The test verifies that the release action is called automatically when the
 54 * device is released.
 55 */
 56static void drm_test_managed_run_action(struct kunit *test)
 57{
 58	struct managed_test_priv *priv = test->priv;
 59	int ret;
 60
 61	ret = drmm_add_action_or_reset(priv->drm, drm_action, priv);
 62	KUNIT_EXPECT_EQ(test, ret, 0);
 63
 64	ret = drm_dev_register(priv->drm, 0);
 65	KUNIT_ASSERT_EQ(test, ret, 0);
 66
 67	drm_dev_unregister(priv->drm);
 68	drm_kunit_helper_free_device(test, priv->drm->dev);
 69
 70	ret = wait_event_interruptible_timeout(priv->action_wq, priv->action_done,
 71					       msecs_to_jiffies(TEST_TIMEOUT_MS));
 72	KUNIT_EXPECT_GT(test, ret, 0);
 73}
 74
 75static int drm_managed_test_init(struct kunit *test)
 76{
 77	struct managed_test_priv *priv;
 78	struct device *dev;
 79
 80	priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
 81	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
 82	init_waitqueue_head(&priv->action_wq);
 83
 84	dev = drm_kunit_helper_alloc_device(test);
 85	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 86
 87	/*
 88	 * DRM device can't be embedded in priv, since priv->action_done needs
 89	 * to remain allocated beyond both parent device and drm_device
 90	 * lifetime.
 91	 */
 92	priv->drm = __drm_kunit_helper_alloc_drm_device(test, dev, sizeof(*priv->drm), 0,
 93							DRIVER_MODESET);
 94	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->drm);
 95
 96	test->priv = priv;
 97
 98	return 0;
 99}
100
101static struct kunit_case drm_managed_tests[] = {
102	KUNIT_CASE(drm_test_managed_release_action),
103	KUNIT_CASE(drm_test_managed_run_action),
104	{}
105};
106
107static struct kunit_suite drm_managed_test_suite = {
108	.name = "drm_managed",
109	.init = drm_managed_test_init,
110	.test_cases = drm_managed_tests
111};
112
113kunit_test_suite(drm_managed_test_suite);
114
115MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
116MODULE_LICENSE("GPL");