// 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_objs(struct page *, npages);
        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);