bybrooklyn/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-04-22 00:33:58 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge tag 'drm-misc-next-2026-01-08' of https://gitlab.freedesktop.org/drm/misc/kernel into drm-next

Browse Source 
drm-misc-next for 6.20:

UAPI Changes:

Cross-subsystem Changes:

Core Changes:
  - draw: Add API to check if a format conversion can be done
  - panic: Rename draw_panic_static_* to draw_panic_screen_*, Add kunit
    tests
  - shmem: Improve tests

Driver Changes:
  - ast: Big endian fixes
  - etnaviv: Add PPU flop reset support
  - panfrost: Add GPU_PM_RT support for RZ/G3E SoC
  - panthor: multiple fixes around VM termination, huge page support
  - pl111: Fix build regression
  - v3d: Fix DMA segment size

  - bridge:
    - Add connector argument to .hpd_notify
    - Plenty of patches to convert existing drivers to refcounting
    - Convert Rockchip's inno hdmi support to a proper bridge
    - lontium-lt9611uxc: Switch to HDMI audio helpers

  - panel:
    - New panel: BOE NV140WUM-T08

Signed-off-by: Dave Airlie <airlied@redhat.com>

From: Maxime Ripard <mripard@redhat.com>
Link: https://patch.msgid.link/20260108-literate-nyala-of-courtesy-de501a@houat
This commit is contained in:
Dave Airlie
2026-01-09 12:57:30 +10:00
parent 59260fe582 6a0b99e9fb
commit a87fef0880
61 changed files with 1590 additions and 716 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
drivers/gpu/drm/tests/drm_gem_shmem_test.c
View File

@@ -19,6 +19,8 @@
#include <drm/drm_gem_shmem_helper.h>
#include <drm/drm_kunit_helpers.h>
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
#define TEST_SIZE SZ_1M
#define TEST_BYTE 0xae
@@ -34,6 +36,9 @@ KUNIT_DEFINE_ACTION_WRAPPER(sg_free_table_wrapper, sg_free_table,
KUNIT_DEFINE_ACTION_WRAPPER(drm_gem_shmem_free_wrapper, drm_gem_shmem_free,
struct drm_gem_shmem_object *);
KUNIT_DEFINE_ACTION_WRAPPER(drm_gem_shmem_unpin_wrapper, drm_gem_shmem_unpin,
struct drm_gem_shmem_object *);
/*
* Test creating a shmem GEM object backed by shmem buffer. The test
* case succeeds if the GEM object is successfully allocated with the
@@ -173,7 +178,7 @@ static void drm_gem_shmem_test_vmap(struct kunit *test)
ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
KUNIT_ASSERT_EQ(test, ret, 0);
ret = drm_gem_shmem_vmap_locked(shmem, &map);
ret = drm_gem_shmem_vmap(shmem, &map);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_ASSERT_NOT_NULL(test, shmem->vaddr);
KUNIT_ASSERT_FALSE(test, iosys_map_is_null(&map));
@@ -183,7 +188,7 @@ static void drm_gem_shmem_test_vmap(struct kunit *test)
for (i = 0; i < TEST_SIZE; i++)
KUNIT_EXPECT_EQ(test, iosys_map_rd(&map, i, u8), TEST_BYTE);
drm_gem_shmem_vunmap_locked(shmem, &map);
drm_gem_shmem_vunmap(shmem, &map);
KUNIT_EXPECT_NULL(test, shmem->vaddr);
KUNIT_EXPECT_EQ(test, refcount_read(&shmem->vmap_use_count), 0);
}
@@ -194,7 +199,7 @@ static void drm_gem_shmem_test_vmap(struct kunit *test)
* scatter/gather table large enough to accommodate the backing memory
* is successfully exported.
*/
static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
static void drm_gem_shmem_test_get_sg_table(struct kunit *test)
{
struct drm_device *drm_dev = test->priv;
struct drm_gem_shmem_object *shmem;
@@ -212,6 +217,9 @@ static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
ret = drm_gem_shmem_pin(shmem);
KUNIT_ASSERT_EQ(test, ret, 0);
ret = kunit_add_action_or_reset(test, drm_gem_shmem_unpin_wrapper, shmem);
KUNIT_ASSERT_EQ(test, ret, 0);
sgt = drm_gem_shmem_get_sg_table(shmem);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, sgt);
KUNIT_EXPECT_NULL(test, shmem->sgt);
@@ -236,7 +244,7 @@ static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
* backing pages are pinned and a scatter/gather table large enough to
* accommodate the backing memory is successfully exported.
*/
static void drm_gem_shmem_test_get_sg_table(struct kunit *test)
static void drm_gem_shmem_test_get_pages_sgt(struct kunit *test)
{
struct drm_device *drm_dev = test->priv;
struct drm_gem_shmem_object *shmem;
@@ -284,17 +292,17 @@ static void drm_gem_shmem_test_madvise(struct kunit *test)
ret = kunit_add_action_or_reset(test, drm_gem_shmem_free_wrapper, shmem);
KUNIT_ASSERT_EQ(test, ret, 0);
ret = drm_gem_shmem_madvise_locked(shmem, 1);
ret = drm_gem_shmem_madvise(shmem, 1);
KUNIT_EXPECT_TRUE(test, ret);
KUNIT_ASSERT_EQ(test, shmem->madv, 1);
/* Set madv to a negative value */
ret = drm_gem_shmem_madvise_locked(shmem, -1);
ret = drm_gem_shmem_madvise(shmem, -1);
KUNIT_EXPECT_FALSE(test, ret);
KUNIT_ASSERT_EQ(test, shmem->madv, -1);
/* Check that madv cannot be set back to a positive value */
ret = drm_gem_shmem_madvise_locked(shmem, 0);
ret = drm_gem_shmem_madvise(shmem, 0);
KUNIT_EXPECT_FALSE(test, ret);
KUNIT_ASSERT_EQ(test, shmem->madv, -1);
}
@@ -322,7 +330,7 @@ static void drm_gem_shmem_test_purge(struct kunit *test)
ret = drm_gem_shmem_is_purgeable(shmem);
KUNIT_EXPECT_FALSE(test, ret);
ret = drm_gem_shmem_madvise_locked(shmem, 1);
ret = drm_gem_shmem_madvise(shmem, 1);
KUNIT_EXPECT_TRUE(test, ret);
/* The scatter/gather table will be freed by drm_gem_shmem_free */
@@ -332,7 +340,9 @@ static void drm_gem_shmem_test_purge(struct kunit *test)
ret = drm_gem_shmem_is_purgeable(shmem);
KUNIT_EXPECT_TRUE(test, ret);
drm_gem_shmem_purge_locked(shmem);
ret = drm_gem_shmem_purge(shmem);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_EXPECT_NULL(test, shmem->pages);
KUNIT_EXPECT_NULL(test, shmem->sgt);
KUNIT_EXPECT_EQ(test, shmem->madv, -1);
@@ -366,8 +376,8 @@ static struct kunit_case drm_gem_shmem_test_cases[] = {
KUNIT_CASE(drm_gem_shmem_test_obj_create_private),
KUNIT_CASE(drm_gem_shmem_test_pin_pages),
KUNIT_CASE(drm_gem_shmem_test_vmap),
KUNIT_CASE(drm_gem_shmem_test_get_pages_sgt),
KUNIT_CASE(drm_gem_shmem_test_get_sg_table),
KUNIT_CASE(drm_gem_shmem_test_get_pages_sgt),
KUNIT_CASE(drm_gem_shmem_test_madvise),
KUNIT_CASE(drm_gem_shmem_test_purge),
{}

221
drivers/gpu/drm/tests/drm_panic_test.c Normal file
View File

@@ -0,0 +1,221 @@
// SPDX-License-Identifier: GPL-2.0 or MIT
/*
* Copyright (c) 2025 Red Hat.
* Author: Jocelyn Falempe <jfalempe@redhat.com>
*
* KUNIT tests for drm panic
*/
#include <drm/drm_fourcc.h>
#include <drm/drm_panic.h>
#include <kunit/test.h>
#include <linux/units.h>
#include <linux/vmalloc.h>
/* Check the framebuffer color only if the panic colors are the default */
#if (CONFIG_DRM_PANIC_BACKGROUND_COLOR == 0 && \
CONFIG_DRM_PANIC_FOREGROUND_COLOR == 0xffffff)
static void drm_panic_check_color_byte(struct kunit *test, u8 b)
{
KUNIT_EXPECT_TRUE(test, (b == 0 || b == 0xff));
}
#else
static void drm_panic_check_color_byte(struct kunit *test, u8 b) {}
#endif
struct drm_test_mode {
const int width;
const int height;
const u32 format;
void (*draw_screen)(struct drm_scanout_buffer *sb);
const char *fname;
};
/*
* Run all tests for the 3 panic screens: user, kmsg and qr_code
*/
#define DRM_TEST_MODE_LIST(func) \
DRM_PANIC_TEST_MODE(1024, 768, DRM_FORMAT_XRGB8888, func) \
DRM_PANIC_TEST_MODE(300, 200, DRM_FORMAT_XRGB8888, func) \
DRM_PANIC_TEST_MODE(1920, 1080, DRM_FORMAT_XRGB8888, func) \
DRM_PANIC_TEST_MODE(1024, 768, DRM_FORMAT_RGB565, func) \
DRM_PANIC_TEST_MODE(1024, 768, DRM_FORMAT_RGB888, func) \
#define DRM_PANIC_TEST_MODE(w, h, f, name) { \
.width = w, \
.height = h, \
.format = f, \
.draw_screen = draw_panic_screen_##name, \
.fname = #name, \
}, \
static const struct drm_test_mode drm_test_modes_cases[] = {
DRM_TEST_MODE_LIST(user)
DRM_TEST_MODE_LIST(kmsg)
#if IS_ENABLED(CONFIG_DRM_PANIC_SCREEN_QR_CODE)
DRM_TEST_MODE_LIST(qr_code)
#endif
};
#undef DRM_PANIC_TEST_MODE
static int drm_test_panic_init(struct kunit *test)
{
struct drm_scanout_buffer *priv;
priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, priv);
test->priv = priv;
drm_panic_set_description("Kunit testing");
return 0;
}
/*
* Test drawing the panic screen, using a memory mapped framebuffer
* Set the whole buffer to 0xa5, and then check that all pixels have been
* written.
*/
static void drm_test_panic_screen_user_map(struct kunit *test)
{
struct drm_scanout_buffer *sb = test->priv;
const struct drm_test_mode *params = test->param_value;
char *fb;
int fb_size;
int i;
sb->format = drm_format_info(params->format);
fb_size = params->width * params->height * sb->format->cpp[0];
fb = vmalloc(fb_size);
KUNIT_ASSERT_NOT_NULL(test, fb);
memset(fb, 0xa5, fb_size);
iosys_map_set_vaddr(&sb->map[0], fb);
sb->width = params->width;
sb->height = params->height;
sb->pitch[0] = params->width * sb->format->cpp[0];
params->draw_screen(sb);
for (i = 0; i < fb_size; i++)
drm_panic_check_color_byte(test, fb[i]);
vfree(fb);
}
/*
* Test drawing the panic screen, using a list of pages framebuffer
* Set the whole buffer to 0xa5, and then check that all pixels have been
* written.
*/
static void drm_test_panic_screen_user_page(struct kunit *test)
{
struct drm_scanout_buffer *sb = test->priv;
const struct drm_test_mode *params = test->param_value;
int fb_size, p, i, npages;
struct page **pages;
u8 *vaddr;
sb->format = drm_format_info(params->format);
fb_size = params->width * params->height * sb->format->cpp[0];
npages = DIV_ROUND_UP(fb_size, PAGE_SIZE);
pages = kmalloc_array(npages, sizeof(struct page *), GFP_KERNEL);
KUNIT_ASSERT_NOT_NULL(test, pages);
for (p = 0; p < npages; p++) {
pages[p] = alloc_page(GFP_KERNEL);
if (!pages[p]) {
npages = p - 1;
KUNIT_FAIL(test, "Can't allocate page\n");
goto free_pages;
}
vaddr = kmap_local_page(pages[p]);
memset(vaddr, 0xa5, PAGE_SIZE);
kunmap_local(vaddr);
}
sb->pages = pages;
sb->width = params->width;
sb->height = params->height;
sb->pitch[0] = params->width * sb->format->cpp[0];
params->draw_screen(sb);
for (p = 0; p < npages; p++) {
int bytes_in_page = (p == npages - 1) ? fb_size - p * PAGE_SIZE : PAGE_SIZE;
vaddr = kmap_local_page(pages[p]);
for (i = 0; i < bytes_in_page; i++)
drm_panic_check_color_byte(test, vaddr[i]);
kunmap_local(vaddr);
}
free_pages:
for (p = 0; p < npages; p++)
__free_page(pages[p]);
kfree(pages);
}
static void drm_test_panic_set_pixel(struct drm_scanout_buffer *sb,
unsigned int x,
unsigned int y,
u32 color)
{
struct kunit *test = (struct kunit *)sb->private;
KUNIT_ASSERT_TRUE(test, x < sb->width && y < sb->height);
}
/*
* Test drawing the panic screen, using the set_pixel callback
* Check that all calls to set_pixel() are within the framebuffer
*/
static void drm_test_panic_screen_user_set_pixel(struct kunit *test)
{
struct drm_scanout_buffer *sb = test->priv;
const struct drm_test_mode *params = test->param_value;
sb->format = drm_format_info(params->format);
sb->set_pixel = drm_test_panic_set_pixel;
sb->width = params->width;
sb->height = params->height;
sb->private = test;
params->draw_screen(sb);
}
static void drm_test_panic_desc(const struct drm_test_mode *t, char *desc)
{
sprintf(desc, "Panic screen %s, mode: %d x %d \t%p4cc",
t->fname, t->width, t->height, &t->format);
}
KUNIT_ARRAY_PARAM(drm_test_panic_screen_user_map, drm_test_modes_cases, drm_test_panic_desc);
KUNIT_ARRAY_PARAM(drm_test_panic_screen_user_page, drm_test_modes_cases, drm_test_panic_desc);
KUNIT_ARRAY_PARAM(drm_test_panic_screen_user_set_pixel, drm_test_modes_cases, drm_test_panic_desc);
static struct kunit_case drm_panic_screen_user_test[] = {
KUNIT_CASE_PARAM(drm_test_panic_screen_user_map,
drm_test_panic_screen_user_map_gen_params),
KUNIT_CASE_PARAM(drm_test_panic_screen_user_page,
drm_test_panic_screen_user_page_gen_params),
KUNIT_CASE_PARAM(drm_test_panic_screen_user_set_pixel,
drm_test_panic_screen_user_set_pixel_gen_params),
{ }
};
static struct kunit_suite drm_panic_suite = {
.name = "drm_panic",
.init = drm_test_panic_init,
.test_cases = drm_panic_screen_user_test,
};
kunit_test_suite(drm_panic_suite);