drivers/gpu/drm/tests/drm_kunit_helpers.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0

 #include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
 #include <drm/drm_drv.h>
 #include <drm/drm_fourcc.h>
 #include <drm/drm_kunit_helpers.h>
 #include <drm/drm_managed.h>

 #include <kunit/device.h>
 #include <kunit/resource.h>

 #include <linux/device.h>
 #include <linux/platform_device.h>

 #define KUNIT_DEVICE_NAME	"drm-kunit-mock-device"

 static const struct drm_mode_config_funcs drm_mode_config_funcs = {
 	.atomic_check	= drm_atomic_helper_check,
 	.atomic_commit	= drm_atomic_helper_commit,
 };

 /**
  * drm_kunit_helper_alloc_device - Allocate a mock device for a KUnit test
  * @test: The test context object
  *
  * This allocates a fake struct &device to create a mock for a KUnit
  * test. The device will also be bound to a fake driver. It will thus be
  * able to leverage the usual infrastructure and most notably the
  * device-managed resources just like a "real" device.
  *
  * Resources will be cleaned up automatically, but the removal can be
  * forced using @drm_kunit_helper_free_device.
  *
  * Returns:
  * A pointer to the new device, or an ERR_PTR() otherwise.
  */
 struct device *drm_kunit_helper_alloc_device(struct kunit *test)
 {
 	return kunit_device_register(test, KUNIT_DEVICE_NAME);
 }
 EXPORT_SYMBOL_GPL(drm_kunit_helper_alloc_device);

 /**
  * drm_kunit_helper_free_device - Frees a mock device
  * @test: The test context object
  * @dev: The device to free
  *
  * Frees a device allocated with drm_kunit_helper_alloc_device().
  */
 void drm_kunit_helper_free_device(struct kunit *test, struct device *dev)
 {
 	kunit_device_unregister(test, dev);
 }
 EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);

 struct drm_device *
 __drm_kunit_helper_alloc_drm_device_with_driver(struct kunit *test,
 						struct device *dev,
 						size_t size, size_t offset,
 						const struct drm_driver *driver)
 {
 	struct drm_device *drm;
 	void *container;
 	int ret;

 	container = __devm_drm_dev_alloc(dev, driver, size, offset);
 	if (IS_ERR(container))
 		return ERR_CAST(container);

 	drm = container + offset;
 	drm->mode_config.funcs = &drm_mode_config_funcs;

 	ret = drmm_mode_config_init(drm);
 	if (ret)
 		return ERR_PTR(ret);

 	return drm;
 }
 EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver);

 static void action_drm_release_context(void *ptr)
 {
 	struct drm_modeset_acquire_ctx *ctx = ptr;

 	drm_modeset_drop_locks(ctx);
 	drm_modeset_acquire_fini(ctx);
 }

 /**
  * drm_kunit_helper_acquire_ctx_alloc - Allocates an acquire context
  * @test: The test context object
  *
  * Allocates and initializes a modeset acquire context.
  *
  * The context is tied to the kunit test context, so we must not call
  * drm_modeset_acquire_fini() on it, it will be done so automatically.
  *
  * Returns:
  * An ERR_PTR on error, a pointer to the newly allocated context otherwise
  */
 struct drm_modeset_acquire_ctx *
 drm_kunit_helper_acquire_ctx_alloc(struct kunit *test)
 {
 	struct drm_modeset_acquire_ctx *ctx;
 	int ret;

 	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 	KUNIT_ASSERT_NOT_NULL(test, ctx);

 	drm_modeset_acquire_init(ctx, 0);

 	ret = kunit_add_action_or_reset(test,
 					action_drm_release_context,
 					ctx);
 	if (ret)
 		return ERR_PTR(ret);

 	return ctx;
 }
 EXPORT_SYMBOL_GPL(drm_kunit_helper_acquire_ctx_alloc);

 static void kunit_action_drm_atomic_state_put(void *ptr)
 {
 	struct drm_atomic_state *state = ptr;

 	drm_atomic_state_put(state);
 }

 /**
  * drm_kunit_helper_atomic_state_alloc - Allocates an atomic state
  * @test: The test context object
  * @drm: The device to alloc the state for
  * @ctx: Locking context for that atomic update
  *
  * Allocates a empty atomic state.
  *
  * The state is tied to the kunit test context, so we must not call
  * drm_atomic_state_put() on it, it will be done so automatically.
  *
  * Returns:
  * An ERR_PTR on error, a pointer to the newly allocated state otherwise
  */
 struct drm_atomic_state *
 drm_kunit_helper_atomic_state_alloc(struct kunit *test,
 				    struct drm_device *drm,
 				    struct drm_modeset_acquire_ctx *ctx)
 {
 	struct drm_atomic_state *state;
 	int ret;

 	state = drm_atomic_state_alloc(drm);
 	if (!state)
 		return ERR_PTR(-ENOMEM);

 	ret = kunit_add_action_or_reset(test,
 					kunit_action_drm_atomic_state_put,
 					state);
 	if (ret)
 		return ERR_PTR(ret);

 	state->acquire_ctx = ctx;

 	return state;
 }
 EXPORT_SYMBOL_GPL(drm_kunit_helper_atomic_state_alloc);

 static const uint32_t default_plane_formats[] = {
 	DRM_FORMAT_XRGB8888,
 };

 static const uint64_t default_plane_modifiers[] = {
 	DRM_FORMAT_MOD_LINEAR,
 	DRM_FORMAT_MOD_INVALID
 };

 static const struct drm_plane_helper_funcs default_plane_helper_funcs = {
 };

 static const struct drm_plane_funcs default_plane_funcs = {
 	.atomic_destroy_state	= drm_atomic_helper_plane_destroy_state,
 	.atomic_duplicate_state	= drm_atomic_helper_plane_duplicate_state,
 	.reset			= drm_atomic_helper_plane_reset,
 };

 /**
  * drm_kunit_helper_create_primary_plane - Creates a mock primary plane for a KUnit test
  * @test: The test context object
  * @drm: The device to alloc the plane for
  * @funcs: Callbacks for the new plane. Optional.
  * @helper_funcs: Helpers callbacks for the new plane. Optional.
  * @formats: array of supported formats (DRM_FORMAT\_\*). Optional.
  * @num_formats: number of elements in @formats
  * @modifiers: array of struct drm_format modifiers terminated by
  *             DRM_FORMAT_MOD_INVALID. Optional.
  *
  * This allocates and initializes a mock struct &drm_plane meant to be
  * part of a mock device for a KUnit test.
  *
  * Resources will be cleaned up automatically.
  *
  * @funcs will default to the default helpers implementations.
  * @helper_funcs will default to an empty implementation. @formats will
  * default to XRGB8888 only. @modifiers will default to a linear
  * modifier only.
  *
  * Returns:
  * A pointer to the new plane, or an ERR_PTR() otherwise.
  */
 struct drm_plane *
 drm_kunit_helper_create_primary_plane(struct kunit *test,
 				      struct drm_device *drm,
 				      const struct drm_plane_funcs *funcs,
 				      const struct drm_plane_helper_funcs *helper_funcs,
 				      const uint32_t *formats,
 				      unsigned int num_formats,
 				      const uint64_t *modifiers)
 {
 	struct drm_plane *plane;

 	if (!funcs)
 		funcs = &default_plane_funcs;

 	if (!helper_funcs)
 		helper_funcs = &default_plane_helper_funcs;

 	if (!formats || !num_formats) {
 		formats = default_plane_formats;
 		num_formats = ARRAY_SIZE(default_plane_formats);
 	}

 	if (!modifiers)
 		modifiers = default_plane_modifiers;

 	plane = __drmm_universal_plane_alloc(drm,
 					     sizeof(struct drm_plane), 0,
 					     0,
 					     funcs,
 					     formats,
 					     num_formats,
 					     default_plane_modifiers,
 					     DRM_PLANE_TYPE_PRIMARY,
 					     NULL);
 	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);

 	drm_plane_helper_add(plane, helper_funcs);

 	return plane;
 }
 EXPORT_SYMBOL_GPL(drm_kunit_helper_create_primary_plane);

 static const struct drm_crtc_helper_funcs default_crtc_helper_funcs = {
 };

 static const struct drm_crtc_funcs default_crtc_funcs = {
 	.atomic_destroy_state   = drm_atomic_helper_crtc_destroy_state,
 	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
 	.reset                  = drm_atomic_helper_crtc_reset,
 };

 /**
  * drm_kunit_helper_create_crtc - Creates a mock CRTC for a KUnit test
  * @test: The test context object
  * @drm: The device to alloc the plane for
  * @primary: Primary plane for CRTC
  * @cursor: Cursor plane for CRTC. Optional.
  * @funcs: Callbacks for the new plane. Optional.
  * @helper_funcs: Helpers callbacks for the new plane. Optional.
  *
  * This allocates and initializes a mock struct &drm_crtc meant to be
  * part of a mock device for a KUnit test.
  *
  * Resources will be cleaned up automatically.
  *
  * @funcs will default to the default helpers implementations.
  * @helper_funcs will default to an empty implementation.
  *
  * Returns:
  * A pointer to the new CRTC, or an ERR_PTR() otherwise.
  */
 struct drm_crtc *
 drm_kunit_helper_create_crtc(struct kunit *test,
 			     struct drm_device *drm,
 			     struct drm_plane *primary,
 			     struct drm_plane *cursor,
 			     const struct drm_crtc_funcs *funcs,
 			     const struct drm_crtc_helper_funcs *helper_funcs)
 {
 	struct drm_crtc *crtc;
 	int ret;

 	if (!funcs)
 		funcs = &default_crtc_funcs;

 	if (!helper_funcs)
 		helper_funcs = &default_crtc_helper_funcs;

 	crtc = drmm_kzalloc(drm, sizeof(*crtc), GFP_KERNEL);
 	KUNIT_ASSERT_NOT_NULL(test, crtc);

 	ret = drmm_crtc_init_with_planes(drm, crtc,
 					 primary,
 					 cursor,
 					 funcs,
 					 NULL);
 	KUNIT_ASSERT_EQ(test, ret, 0);

 	drm_crtc_helper_add(crtc, helper_funcs);

 	return crtc;
 }
 EXPORT_SYMBOL_GPL(drm_kunit_helper_create_crtc);

 MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
 MODULE_DESCRIPTION("KUnit test suite helper functions");
 MODULE_LICENSE("GPL");
	// SPDX-License-Identifier: GPL-2.0

	#include <drm/drm_atomic.h>
	#include <drm/drm_atomic_helper.h>
	#include <drm/drm_drv.h>
	#include <drm/drm_fourcc.h>
	#include <drm/drm_kunit_helpers.h>
	#include <drm/drm_managed.h>

	#include <kunit/device.h>
	#include <kunit/resource.h>

	#include <linux/device.h>
	#include <linux/platform_device.h>

	#define KUNIT_DEVICE_NAME "drm-kunit-mock-device"

	static const struct drm_mode_config_funcs drm_mode_config_funcs = {
	.atomic_check = drm_atomic_helper_check,
	.atomic_commit = drm_atomic_helper_commit,
	};

	/**
	* drm_kunit_helper_alloc_device - Allocate a mock device for a KUnit test
	* @test: The test context object
	*
	* This allocates a fake struct &device to create a mock for a KUnit
	* test. The device will also be bound to a fake driver. It will thus be
	* able to leverage the usual infrastructure and most notably the
	* device-managed resources just like a "real" device.
	*
	* Resources will be cleaned up automatically, but the removal can be
	* forced using @drm_kunit_helper_free_device.
	*
	* Returns:
	* A pointer to the new device, or an ERR_PTR() otherwise.
	*/
	struct device drm_kunit_helper_alloc_device(struct kunit test)
	{
	return kunit_device_register(test, KUNIT_DEVICE_NAME);
	}
	EXPORT_SYMBOL_GPL(drm_kunit_helper_alloc_device);

	/**
	* drm_kunit_helper_free_device - Frees a mock device
	* @test: The test context object
	* @dev: The device to free
	*
	* Frees a device allocated with drm_kunit_helper_alloc_device().
	*/
	void drm_kunit_helper_free_device(struct kunit test, struct device dev)
	{
	kunit_device_unregister(test, dev);
	}
	EXPORT_SYMBOL_GPL(drm_kunit_helper_free_device);

	struct drm_device *
	__drm_kunit_helper_alloc_drm_device_with_driver(struct kunit *test,
	struct device *dev,
	size_t size, size_t offset,
	const struct drm_driver *driver)
	{
	struct drm_device *drm;
	void *container;
	int ret;

	container = __devm_drm_dev_alloc(dev, driver, size, offset);
	if (IS_ERR(container))
	return ERR_CAST(container);

	drm = container + offset;
	drm->mode_config.funcs = &drm_mode_config_funcs;

	ret = drmm_mode_config_init(drm);
	if (ret)
	return ERR_PTR(ret);

	return drm;
	}
	EXPORT_SYMBOL_GPL(__drm_kunit_helper_alloc_drm_device_with_driver);

	static void action_drm_release_context(void *ptr)
	{
	struct drm_modeset_acquire_ctx *ctx = ptr;

	drm_modeset_drop_locks(ctx);
	drm_modeset_acquire_fini(ctx);
	}

	/**
	* drm_kunit_helper_acquire_ctx_alloc - Allocates an acquire context
	* @test: The test context object
	*
	* Allocates and initializes a modeset acquire context.
	*
	* The context is tied to the kunit test context, so we must not call
	* drm_modeset_acquire_fini() on it, it will be done so automatically.
	*
	* Returns:
	* An ERR_PTR on error, a pointer to the newly allocated context otherwise
	*/
	struct drm_modeset_acquire_ctx *
	drm_kunit_helper_acquire_ctx_alloc(struct kunit *test)
	{
	struct drm_modeset_acquire_ctx *ctx;
	int ret;

	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, ctx);

	drm_modeset_acquire_init(ctx, 0);

	ret = kunit_add_action_or_reset(test,
	action_drm_release_context,
	ctx);
	if (ret)
	return ERR_PTR(ret);

	return ctx;
	}
	EXPORT_SYMBOL_GPL(drm_kunit_helper_acquire_ctx_alloc);

	static void kunit_action_drm_atomic_state_put(void *ptr)
	{
	struct drm_atomic_state *state = ptr;

	drm_atomic_state_put(state);
	}

	/**
	* drm_kunit_helper_atomic_state_alloc - Allocates an atomic state
	* @test: The test context object
	* @drm: The device to alloc the state for
	* @ctx: Locking context for that atomic update
	*
	* Allocates a empty atomic state.
	*
	* The state is tied to the kunit test context, so we must not call
	* drm_atomic_state_put() on it, it will be done so automatically.
	*
	* Returns:
	* An ERR_PTR on error, a pointer to the newly allocated state otherwise
	*/
	struct drm_atomic_state *
	drm_kunit_helper_atomic_state_alloc(struct kunit *test,
	struct drm_device *drm,
	struct drm_modeset_acquire_ctx *ctx)
	{
	struct drm_atomic_state *state;
	int ret;

	state = drm_atomic_state_alloc(drm);
	if (!state)
	return ERR_PTR(-ENOMEM);

	ret = kunit_add_action_or_reset(test,
	kunit_action_drm_atomic_state_put,
	state);
	if (ret)
	return ERR_PTR(ret);

	state->acquire_ctx = ctx;

	return state;
	}
	EXPORT_SYMBOL_GPL(drm_kunit_helper_atomic_state_alloc);

	static const uint32_t default_plane_formats[] = {
	DRM_FORMAT_XRGB8888,
	};

	static const uint64_t default_plane_modifiers[] = {
	DRM_FORMAT_MOD_LINEAR,
	DRM_FORMAT_MOD_INVALID
	};

	static const struct drm_plane_helper_funcs default_plane_helper_funcs = {
	};

	static const struct drm_plane_funcs default_plane_funcs = {
	.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
	.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
	.reset = drm_atomic_helper_plane_reset,
	};

	/**
	* drm_kunit_helper_create_primary_plane - Creates a mock primary plane for a KUnit test
	* @test: The test context object
	* @drm: The device to alloc the plane for
	* @funcs: Callbacks for the new plane. Optional.
	* @helper_funcs: Helpers callbacks for the new plane. Optional.
	* @formats: array of supported formats (DRM_FORMAT\_\*). Optional.
	* @num_formats: number of elements in @formats
	* @modifiers: array of struct drm_format modifiers terminated by
	* DRM_FORMAT_MOD_INVALID. Optional.
	*
	* This allocates and initializes a mock struct &drm_plane meant to be
	* part of a mock device for a KUnit test.
	*
	* Resources will be cleaned up automatically.
	*
	* @funcs will default to the default helpers implementations.
	* @helper_funcs will default to an empty implementation. @formats will
	* default to XRGB8888 only. @modifiers will default to a linear
	* modifier only.
	*
	* Returns:
	* A pointer to the new plane, or an ERR_PTR() otherwise.
	*/
	struct drm_plane *
	drm_kunit_helper_create_primary_plane(struct kunit *test,
	struct drm_device *drm,
	const struct drm_plane_funcs *funcs,
	const struct drm_plane_helper_funcs *helper_funcs,
	const uint32_t *formats,
	unsigned int num_formats,
	const uint64_t *modifiers)
	{
	struct drm_plane *plane;

	if (!funcs)
	funcs = &default_plane_funcs;

	if (!helper_funcs)
	helper_funcs = &default_plane_helper_funcs;

	if (!formats \|\| !num_formats) {
	formats = default_plane_formats;
	num_formats = ARRAY_SIZE(default_plane_formats);
	}

	if (!modifiers)
	modifiers = default_plane_modifiers;

	plane = __drmm_universal_plane_alloc(drm,
	sizeof(struct drm_plane), 0,
	0,
	funcs,
	formats,
	num_formats,
	default_plane_modifiers,
	DRM_PLANE_TYPE_PRIMARY,
	NULL);
	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, plane);

	drm_plane_helper_add(plane, helper_funcs);

	return plane;
	}
	EXPORT_SYMBOL_GPL(drm_kunit_helper_create_primary_plane);

	static const struct drm_crtc_helper_funcs default_crtc_helper_funcs = {
	};

	static const struct drm_crtc_funcs default_crtc_funcs = {
	.atomic_destroy_state = drm_atomic_helper_crtc_destroy_state,
	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,
	.reset = drm_atomic_helper_crtc_reset,
	};

	/**
	* drm_kunit_helper_create_crtc - Creates a mock CRTC for a KUnit test
	* @test: The test context object
	* @drm: The device to alloc the plane for
	* @primary: Primary plane for CRTC
	* @cursor: Cursor plane for CRTC. Optional.
	* @funcs: Callbacks for the new plane. Optional.
	* @helper_funcs: Helpers callbacks for the new plane. Optional.
	*
	* This allocates and initializes a mock struct &drm_crtc meant to be
	* part of a mock device for a KUnit test.
	*
	* Resources will be cleaned up automatically.
	*
	* @funcs will default to the default helpers implementations.
	* @helper_funcs will default to an empty implementation.
	*
	* Returns:
	* A pointer to the new CRTC, or an ERR_PTR() otherwise.
	*/
	struct drm_crtc *
	drm_kunit_helper_create_crtc(struct kunit *test,
	struct drm_device *drm,
	struct drm_plane *primary,
	struct drm_plane *cursor,
	const struct drm_crtc_funcs *funcs,
	const struct drm_crtc_helper_funcs *helper_funcs)
	{
	struct drm_crtc *crtc;
	int ret;

	if (!funcs)
	funcs = &default_crtc_funcs;

	if (!helper_funcs)
	helper_funcs = &default_crtc_helper_funcs;

	crtc = drmm_kzalloc(drm, sizeof(*crtc), GFP_KERNEL);
	KUNIT_ASSERT_NOT_NULL(test, crtc);

	ret = drmm_crtc_init_with_planes(drm, crtc,
	primary,
	cursor,
	funcs,
	NULL);
	KUNIT_ASSERT_EQ(test, ret, 0);

	drm_crtc_helper_add(crtc, helper_funcs);

	return crtc;
	}
	EXPORT_SYMBOL_GPL(drm_kunit_helper_create_crtc);

	MODULE_AUTHOR("Maxime Ripard <maxime@cerno.tech>");
	MODULE_DESCRIPTION("KUnit test suite helper functions");
	MODULE_LICENSE("GPL");