// SPDX-License-Identifier: (GPL-2.0+ OR MIT)
/*
 * Copyright (c) 2022 Rockchip Electronics Co., Ltd.
 * Author: Sandy Huang <hjc@rock-chips.com>
 */

#include <linux/delay.h>
#include <linux/init.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/workqueue.h>

#include <drm/drm_atomic_uapi.h>

#include "rockchip_drm_drv.h"
#include "rockchip_drm_direct_show.h"
#include "rockchip_drm_display_pattern.h"

#include "kernel_logo_img.h"

#define USE_BUFFER_NUM	2
#define BUFFER_WIDTH	652
#define BUFFER_HEIGHT	268
#define BUFFER_FORMAT	DRM_FORMAT_RGB565 /* DRM_FORMAT_RGB565/DRM_FORMAT_XRGB8888/DRM_FORMAT_NV12 */

struct rockchip_drm_self_test {
	struct drm_device *dev;
	struct work_struct commit_work;
	struct workqueue_struct *workqueue;

	struct drm_crtc *crtc;
	struct drm_plane *plane;

	struct rockchip_drm_direct_show_buffer *drm_buffer[USE_BUFFER_NUM];
};

static struct rockchip_drm_self_test rockchip_drm_st;

static void __maybe_unused
rockchip_drm_draw_white(struct rockchip_drm_direct_show_buffer *buffer)
{
	if (buffer && buffer->vir_addr[0])
		memset(buffer->vir_addr[0], 0xff, buffer->pitch[0] * buffer->height);
}

static void __maybe_unused
rockchip_drm_draw_gray128(struct rockchip_drm_direct_show_buffer *buffer)
{
	if (buffer && buffer->vir_addr[0])
		memset(buffer->vir_addr[0], 0x80, buffer->pitch[0] * buffer->height);
}

static void __maybe_unused
rockchip_drm_copy_bmp_file(struct rockchip_drm_direct_show_buffer *buffer)
{
	int i = 0;
	void *src, *dst;

	if (!buffer || !buffer->vir_addr[0]) {
		pr_info("%s[%d] buffer or buffer->vir_addr[0] is NULL\n", __func__, __LINE__);
		return;
	}

	src = (void *)bmp_file;
	dst = (void *)buffer->vir_addr[0];
	for (i = 0; i < buffer->height; i++) {
		memcpy(dst, src, buffer->pitch[0]);
		src += BUFFER_WIDTH * buffer->bpp >> 3;
		dst += buffer->pitch[0];
	}
}

static void __maybe_unused
rockchip_drm_draw_color_bar(struct rockchip_drm_direct_show_buffer *buffer)
{
	if (buffer && buffer->vir_addr[0])
		rockchip_drm_fill_color_bar(buffer->pixel_format,
					    buffer->vir_addr,
					    buffer->width,
					    buffer->height,
					    buffer->pitch[0]);
}

static int rockchip_drm_self_test_alloc_buffer(struct rockchip_drm_self_test *self_test)
{
	int ret = 0, i = 0;
	struct rockchip_drm_direct_show_buffer *buffer;

	for (i = 0; i < USE_BUFFER_NUM; i++) {
		buffer = kmalloc(sizeof(struct rockchip_drm_direct_show_buffer), GFP_KERNEL);
		if (!buffer)
			return -ENOMEM;
		buffer->width = BUFFER_WIDTH;
		buffer->height = BUFFER_HEIGHT;
		buffer->pixel_format = BUFFER_FORMAT;
		buffer->flag = ROCKCHIP_BO_CONTIG;
		ret = rockchip_drm_direct_show_alloc_buffer(self_test->dev, buffer);
		if (ret)
			pr_info("failed to alloc drm buffer\n");
		self_test->drm_buffer[i] = buffer;
	}

	return 0;
}

static int rockchip_drm_self_test_free_buffer(struct rockchip_drm_self_test *self_test)
{
	int i = 0;

	for (i = 0; i < USE_BUFFER_NUM; i++)
		rockchip_drm_direct_show_free_buffer(self_test->dev, self_test->drm_buffer[i]);

	return 0;
}

static void rockchip_drm_self_test_commit(struct work_struct *work)
{
	struct rockchip_drm_self_test *self_test =
			container_of(work, struct rockchip_drm_self_test, commit_work);
	struct rockchip_drm_direct_show_commit_info commit_info;
	int ret = 0;

	if (!self_test->dev)
		self_test->dev = rockchip_drm_get_dev();

	/* drm is unready */
	if (!self_test->dev) {
		pr_info("%s[%d], drm is unready\n", __func__, __LINE__);
		msleep(100);
		queue_work(self_test->workqueue, &self_test->commit_work);

		return;
	}

	/* alloc buffer */
	if (!self_test->drm_buffer[0]) {
		ret = rockchip_drm_self_test_alloc_buffer(self_test);
		if (ret)
			pr_info("error: drm self test alloc buffer error\n");
	}

	/* draw buffer */
	rockchip_drm_copy_bmp_file(self_test->drm_buffer[0]);
	/* rockchip_drm_draw_gray128(self_test->drm_buffer[1]); */
	rockchip_drm_draw_color_bar(self_test->drm_buffer[1]);

	/* get crtc and plane */
	self_test->crtc = rockchip_drm_direct_show_get_crtc(self_test->dev, NULL);
	if (self_test->crtc == NULL) {
		pr_info("error: failed to get crtc\n");
		goto free_buffer;
	}

	self_test->plane = rockchip_drm_direct_show_get_plane(self_test->dev, "Esmart0-win0");
	if (self_test->plane == NULL) {
		pr_info("error: failed to get plane\n");
		goto free_buffer;
	}

#if 1	/* for self test pattern */
	/* commit to display */
	do {
		u32 i = 0;

		commit_info.crtc = self_test->crtc;
		commit_info.plane = self_test->plane;

		commit_info.src_x = 0;
		commit_info.src_y = 0;
		commit_info.src_w = BUFFER_WIDTH;
		commit_info.src_h = BUFFER_HEIGHT;

		commit_info.dst_x = 0;
		commit_info.dst_y = 0;
		commit_info.dst_w = commit_info.src_w;
		commit_info.dst_h = commit_info.src_h;

		commit_info.top_zpos = true;

		for (i = 0; i < 1000; i++) {
			commit_info.buffer = self_test->drm_buffer[i % 2];/* two buffer ping pong */
			rockchip_drm_direct_show_commit(self_test->dev, &commit_info);
			mdelay(1000);
		}
		/* disable plane */
		rockchip_drm_direct_show_disable_plane(self_test->dev, commit_info.plane);
		/* free buffer */
		rockchip_drm_self_test_free_buffer(self_test);
	} while (0);
#else
	/* for kernel logo display */
	do {
		int hdisplay = self_test->crtc->state->adjusted_mode.hdisplay;
		int vdisplay = self_test->crtc->state->adjusted_mode.vdisplay;

		commit_info.crtc = self_test->crtc;
		commit_info.plane = self_test->plane;

		commit_info.src_x = 0;
		commit_info.src_y = 0;
		commit_info.src_w = self_test->drm_buffer[0]->width;
		commit_info.src_h = self_test->drm_buffer[0]->height;

		if (1) {/* center display */
			commit_info.dst_x = (hdisplay - BUFFER_WIDTH) / 2;
			commit_info.dst_y = (vdisplay - BUFFER_HEIGHT) / 2;
			commit_info.dst_w = commit_info.src_w;
			commit_info.dst_h = commit_info.src_h;

		} else {/* full screen display */
			commit_info.dst_x = 0;
			commit_info.dst_y = 0;
			commit_info.dst_w = hdisplay;
			commit_info.dst_h = vdisplay;
		}

		commit_info.buffer = self_test->drm_buffer[0];
		rockchip_drm_direct_show_commit(self_test->dev, &commit_info);
	} while (0);
#endif
	return;

free_buffer:
	/* free buffer */
	rockchip_drm_self_test_free_buffer(self_test);
}

static int rockchip_drm_self_test_create_worker(struct rockchip_drm_self_test *slef_test)
{
	struct workqueue_struct *wq = NULL;

	wq = create_singlethread_workqueue("rockchip_drm_self_test");
	if (!wq) {
		pr_info("Failed to create rockchip_drm_self_test workqueue\n");
		return -ENODEV;
	}
	slef_test->workqueue = wq;

	return 0;
}

static int __maybe_unused rockchip_drm_self_test_destory_worker(struct rockchip_drm_self_test *slef_test)
{
	if (!slef_test)
		return -ENODEV;

	if (slef_test->workqueue)
		destroy_workqueue(slef_test->workqueue);

	return 0;
}

static int rockchip_drm_self_test_main(void *arg)
{
	rockchip_drm_self_test_create_worker(&rockchip_drm_st);
	INIT_WORK(&rockchip_drm_st.commit_work, rockchip_drm_self_test_commit);
	queue_work(rockchip_drm_st.workqueue, &rockchip_drm_st.commit_work);

	return 0;
};

static int __init rockchip_drm_self_test(void)
{
	kthread_run(rockchip_drm_self_test_main, NULL, "rockchip drm self test");

	return 0;
}

subsys_initcall_sync(rockchip_drm_self_test);