drivers/gpu/drm/tests/drm_kunit_helpers.c

   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 #include <linux/platform_device.h>
  11
  12 #define KUNIT_DEVICE_NAME       "drm-kunit-mock-device"
  13
  14 static const struct drm_mode_config_funcs drm_mode_config_funcs = {
  15 };
  16
  17 static int fake_probe(struct platform_device *pdev)
  18 {
  19         return 0;
  20 }
  21
  22 static int fake_remove(struct platform_device *pdev)
  23 {
  24         return 0;
  25 }
  26
  27 static struct platform_driver fake_platform_driver = {
  28         .probe  = fake_probe,
  29         .remove = fake_remove,
  30         .driver = {
  31                 .name   = KUNIT_DEVICE_NAME,
  32         },
  33 };
  34
  35 /**
  36  * drm_kunit_helper_alloc_device - Allocate a mock device for a KUnit test
  37  * @test: The test context object
  38  *
  39  * This allocates a fake struct &device to create a mock for a KUnit
  40  * test. The device will also be bound to a fake driver. It will thus be
  41  * able to leverage the usual infrastructure and most notably the
  42  * device-managed resources just like a "real" device.
  43  *
  44  * Callers need to make sure drm_kunit_helper_free_device() on the
  45  * device when done.
  46  *
  47  * Returns:
  48  * A pointer to the new device, or an ERR_PTR() otherwise.
  49  */
  50 struct device *drm_kunit_helper_alloc_device(struct kunit *test)
  51 {
  52         struct platform_device *pdev;
  53         int ret;
  54
  55         ret = platform_driver_register(&fake_platform_driver);
  56         KUNIT_ASSERT_EQ(test, ret, 0);
  57
  58         pdev = platform_device_alloc(KUNIT_DEVICE_NAME, PLATFORM_DEVID_NONE);
  59         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, pdev);
  60
  61         ret = platform_device_add(pdev);
  62         KUNIT_ASSERT_EQ(test, ret, 0);
  63
  64         return &pdev->dev;
  65 }
  66 EXPORT_SYMBOL_GPL(drm_kunit_helper_alloc_device);
  67
  68 /**
  69  * drm_kunit_helper_free_device - Frees a mock device
  70  * @test: The test context object
  71  * @dev: The device to free
  72  *
  73  * Frees a device allocated with drm_kunit_helper_alloc_device().
  74  */
  75 void drm_kunit_helper_free_device(struct kunit *test, struct device *dev)
  76 {
  77         struct platform_device *pdev = to_platform_device(dev);
  78
  79         platform_device_unregister(pdev);
  80         platform_driver_unregister(&fake_platform_driver);
  81 }
  82 EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);
  83
  84 struct drm_device *
  85 __drm_kunit_helper_alloc_drm_device_with_driver(struct kunit *test,
  86                                                 struct device *dev,
  87                                                 size_t size, size_t offset,
  88                                                 const struct drm_driver *driver)
  89 {
  90         struct drm_device *drm;
  91         void *container;
  92         int ret;
  93
  94         container = __devm_drm_dev_alloc(dev, driver, size, offset);
  95         if (IS_ERR(container))
  96                 return ERR_CAST(container);
  97
  98         drm = container + offset;
  99         drm->mode_config.funcs = &drm_mode_config_funcs;
 100
 101         ret = drmm_mode_config_init(drm);
 102         if (ret)
 103                 return ERR_PTR(ret);
 104
 105         return drm;
 106 }
 107 EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver);
 108
 109 MODULE_AUTHOR("Maxime Ripard <[email protected]>");
 110 MODULE_LICENSE("GPL");