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	bool action_done;
16	wait_queue_head_t action_wq;
17};
18
19static void drm_action(struct drm_device *drm, void *ptr)
20{
21	struct managed_test_priv *priv = ptr;
22
23	priv->action_done = true;
24	wake_up_interruptible(&priv->action_wq);
25}
26
27static void drm_test_managed_run_action(struct kunit *test)
 
 
 
 
28{
29	struct managed_test_priv *priv;
30	struct drm_device *drm;
31	struct device *dev;
32	int ret;
33
34	priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
35	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv);
36	init_waitqueue_head(&priv->action_wq);
37
38	dev = drm_kunit_helper_alloc_device(test);
39	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dev);
 
 
 
 
 
 
 
 
 
40
41	drm = __drm_kunit_helper_alloc_drm_device(test, dev, sizeof(*drm), 0, DRIVER_MODESET);
42	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, drm);
 
 
 
 
 
 
43
44	ret = drmm_add_action_or_reset(drm, drm_action, priv);
45	KUNIT_EXPECT_EQ(test, ret, 0);
46
47	ret = drm_dev_register(drm, 0);
48	KUNIT_ASSERT_EQ(test, ret, 0);
49
50	drm_dev_unregister(drm);
51	drm_kunit_helper_free_device(test, dev);
52
53	ret = wait_event_interruptible_timeout(priv->action_wq, priv->action_done,
54					       msecs_to_jiffies(TEST_TIMEOUT_MS));
55	KUNIT_EXPECT_GT(test, ret, 0);
56}
57
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
58static struct kunit_case drm_managed_tests[] = {
 
59	KUNIT_CASE(drm_test_managed_run_action),
60	{}
61};
62
63static struct kunit_suite drm_managed_test_suite = {
64	.name = "drm-test-managed",
 
65	.test_cases = drm_managed_tests
66};
67
68kunit_test_suite(drm_managed_test_suite);
69
70MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
 
71MODULE_LICENSE("GPL");

  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_DESCRIPTION("KUnit DRM managed test suite");
117MODULE_LICENSE("GPL");