Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Maxime Ripard | 801 | 99.26% | 20 | 90.91% |
Jeff Johnson | 5 | 0.62% | 1 | 4.55% |
Lee Jones | 1 | 0.12% | 1 | 4.55% |
Total | 807 | 22 |
// 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");
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1