xref: /OK3568_Linux_fs/kernel/drivers/video/rockchip/vehicle/vehicle_flinger.c (revision 4882a59341e53eb6f0b4789bf948001014eff981)

// SPDX-License-Identifier: GPL-2.0
/*
 * drivers/video/rockchip/video/vehicle_flinger.c
 *
 * Copyright (C) 2022 Rockchip Electronics Co., Ltd.
 * Authors:
 *	Jianwei Fan <jianwei.fan@rock-chips.com>
 *
 */

#include <linux/atomic.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/device.h>
#include <linux/kthread.h>
#include <linux/fb.h>
#include <linux/init.h>
#include <linux/vmalloc.h>
#include <asm/div64.h>
#include <linux/uaccess.h>
#include <linux/linux_logo.h>
#include <linux/dma-mapping.h>
#include <linux/regulator/consumer.h>
#include <linux/of_address.h>
#include <linux/memblock.h>
#include <linux/kthread.h>
#include <linux/fdtable.h>
#include <linux/miscdevice.h>
#ifdef CONFIG_OF
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/of_gpio.h>
#include <video/of_display_timing.h>
#include <video/display_timing.h>
#endif

#include "vehicle_flinger.h"
#include "../../../gpu/drm/rockchip/rockchip_drm_direct_show.h"
#include "../drivers/video/rockchip/rga3/include/rga_drv.h"

static int vehicle_dump_cif;
static int vehicle_dump_rga;
static int vehicle_dump_vop;

enum force_value {
	FORCE_WIDTH = 1920,
	FORCE_HEIGHT = 1080,
	FORCE_STRIDE = 1920,
	FORCE_XOFFSET = 0,
	FORCE_YOFFSET = 0,
	FORCE_FORMAT = HAL_PIXEL_FORMAT_YCrCb_NV12,
	FORCE_ROTATION = RGA_TRANSFORM_ROT_0,
};

enum {
	NUM_SOURCE_BUFFERS = 5, /*5 src buffer for cif*/
	NUM_TARGET_BUFFERS = 3, /*3 dst buffer rga*/
};

enum buffer_state {
	UNKNOWN = 0,
	FREE,
	DEQUEUE,
	QUEUE,
	ACQUIRE,
	DISPLAY,
};

struct rect {
	size_t x;
	size_t y;
	size_t w;
	size_t h;
	size_t s;
	size_t f;
};

struct graphic_buffer {
	struct list_head list;
	uint32_t handle;
	struct rockchip_drm_direct_show_buffer *drm_buffer;
	int fd;
	struct sync_fence *rel_fence;
	struct rect src;
	struct rect dst;
	enum buffer_state state;
	unsigned long phy_addr;
	void *vir_addr;
	int rotation;
	int offset;
	int len;
	int width;
	int height;
	int stride;
	int format;
	struct work_struct render_work;
	ktime_t timestamp;
};

struct queue_buffer {
	struct list_head list;
	struct graphic_buffer *buffer;
};

struct flinger {
	struct device *dev;
	struct ion_client *ion_client;
	struct work_struct init_work;
	struct work_struct render_work;
	struct workqueue_struct *render_workqueue;
	struct mutex source_buffer_lock;/*src buffer lock*/
	struct mutex target_buffer_lock;/*dst buffer lock*/
	struct graphic_buffer source_buffer[NUM_SOURCE_BUFFERS];
	struct graphic_buffer target_buffer[NUM_TARGET_BUFFERS];
	struct mutex queue_buffer_lock;
	struct list_head queue_buffer_list;
	wait_queue_head_t worker_wait;
	atomic_t worker_cond_atomic;
	atomic_t worker_running_atomic;
	int source_index;
	int target_index;
	struct vehicle_cfg v_cfg;
	int cvbs_field_count;
	struct graphic_buffer *last_src_buffer;
	/*debug*/
	int debug_cif_count;
	int debug_vop_count;
	bool running;
	struct drm_device *drm_dev;
	struct drm_crtc *crtc;
	struct drm_plane *plane;
	const char *crtc_name;
	const char *plane_name;
};

static struct flinger *flinger;

static int rk_flinger_queue_work(struct flinger *flinger,
				 struct graphic_buffer *src_buffer);

static int rk_flinger_alloc_bpp(int format)
{
	int width = 4;

	switch (format) {
	case HAL_PIXEL_FORMAT_RGB_565:
		width = 2;
		break;
	case HAL_PIXEL_FORMAT_RGB_888:
		width =  3;
		break;
	case HAL_PIXEL_FORMAT_RGBA_8888:
		width =  4;
		break;
	case HAL_PIXEL_FORMAT_RGBX_8888:
		width =  4;
		break;
	case HAL_PIXEL_FORMAT_BGRA_8888:
		width =  4;
		break;
	case HAL_PIXEL_FORMAT_YCrCb_NV12:
		width =  2;
		break;
	default:
		VEHICLE_INFO("%s: unsupported format: 0x%x\n", __func__, format);
		break;
	}

	return width;
}

static int rk_flinger_HAL_format_to_DRM(int format)
{
	int drm_format = 0;

	switch (format) {
	case HAL_PIXEL_FORMAT_RGBX_8888:
		drm_format =  DRM_FORMAT_XRGB8888;
		break;
	case HAL_PIXEL_FORMAT_YCrCb_NV12:
		drm_format =  DRM_FORMAT_NV12;
		break;
	case HAL_PIXEL_FORMAT_RGB_888:
		drm_format =  DRM_FORMAT_RGB888;
		break;
	case HAL_PIXEL_FORMAT_RGB_565:
		drm_format =  DRM_FORMAT_RGB565;
		break;
	default:
		VEHICLE_INFO("%s: unsupported format: 0x%x\n", __func__, format);
		break;
	}

	return drm_format;
}

static int rk_flinger_alloc_buffer(struct flinger *flg,
				   struct graphic_buffer *buffer,
				   int w, int h,
				   int s, int f)
{
	unsigned long phy_addr;
	size_t len;
	int bpp;
	int ret = 0;
	struct rockchip_drm_direct_show_buffer *create_buffer;

	VEHICLE_DG("------------alloc buffer start---------\n");
	if (!flg)
		return -ENODEV;

	if (!buffer)
		return -EINVAL;

	bpp = rk_flinger_alloc_bpp(f);
	len = s * h * bpp;

	create_buffer = kmalloc(sizeof(struct rockchip_drm_direct_show_buffer), GFP_KERNEL);
	if (!create_buffer)
		return -ENOMEM;
	create_buffer->width = w;
	create_buffer->height = h;
	create_buffer->pixel_format = rk_flinger_HAL_format_to_DRM(f);
	create_buffer->flag = ROCKCHIP_BO_CONTIG;

	ret = rockchip_drm_direct_show_alloc_buffer(flg->drm_dev, create_buffer);
	if (ret)
		VEHICLE_DGERR("error: failed to alloc drm buffer\n");

	VEHICLE_DG("-----creat buffer over-----\n");
	buffer->vir_addr = create_buffer->vir_addr[0];
	buffer->handle = create_buffer->dmabuf_fd;
	phy_addr = create_buffer->phy_addr[0];
	buffer->fd = create_buffer->dmabuf_fd;
	buffer->drm_buffer = create_buffer;

	buffer->rel_fence = NULL;
	buffer->phy_addr = phy_addr;
	buffer->rotation = 0;
	buffer->width = w;
	buffer->height = h;
	buffer->stride = s;
	buffer->format = f;
	buffer->len = len;

	return ret;
}

static int rk_flinger_free_buffer(struct flinger *flinger,
			   struct graphic_buffer *buffer)
{
	if (!flinger)
		return -ENODEV;

	if (!buffer)
		return -EINVAL;

	if (buffer->drm_buffer)
		rockchip_drm_direct_show_free_buffer(flinger->drm_dev,
							buffer->drm_buffer);

	return 0;
}

static int rk_flinger_create_worker(struct flinger *flinger)
{
	struct workqueue_struct *wq = NULL;

	wq = create_singlethread_workqueue("flinger-render");
	if (!wq) {
		VEHICLE_DGERR("wzqtest Failed to create flinger workqueue\n");
		return -ENODEV;
	}
	flinger->render_workqueue = wq;

	return 0;
}

static int rk_flinger_destroy_worker(struct flinger *flinger)
{
	if (!flinger)
		return -ENODEV;

	if (flinger->render_workqueue)
		destroy_workqueue(flinger->render_workqueue);

	return 0;
}

static int vehicle_flinger_parse_dt(struct flinger *flinger)
{
	struct device *dev = flinger->dev;

	if (of_property_read_string(dev->of_node, "vehicle,crtc_name", &flinger->crtc_name)) {
		dev_info(dev, "%s: get crtc_name failed, use default!\n", __func__);
		flinger->crtc_name = "video_port3";
	} else {
		dev_info(dev, "%s: get crtc name from dts, crtc-name = %s\n",
							__func__, flinger->crtc_name);
	}

	if (of_property_read_string(dev->of_node, "vehicle,plane_name", &flinger->plane_name)) {
		dev_info(dev, "%s: get crtc_name failed, use default!\n", __func__);
		flinger->plane_name = "Esmart3-win0";
	} else {
		dev_info(dev, "%s: get crtc name from dts, crtc-name = %s\n",
							__func__, flinger->plane_name);
	}

	return 0;
}

int vehicle_flinger_init(struct device *dev, struct vehicle_cfg *v_cfg)
{
	struct graphic_buffer *buffer;
	struct flinger *flg = NULL;
	int i, ret, w, h, s, f;
	static bool inited;

	if (inited)
		return 0;

	VEHICLE_INFO("%s: v_cfg->rotate_mirror(0x%x)\n", __func__, v_cfg->rotate_mirror);

	// if (FORCE_ROTATION == RGA_TRANSFORM_ROT_270 || FORCE_ROTATION == RGA_TRANSFORM_ROT_90) {
	if ((v_cfg->rotate_mirror & RGA_TRANSFORM_ROT_MASK) == 0x01 ||
	    (v_cfg->rotate_mirror & RGA_TRANSFORM_ROT_MASK) == 0x04) {
		w = FORCE_WIDTH;
		h = ALIGN(FORCE_HEIGHT, 64);
		s = ALIGN(FORCE_HEIGHT, 64);
		f = FORCE_FORMAT;
	} else {
		w = ALIGN(FORCE_WIDTH, 64);
		h = FORCE_HEIGHT;
		s = ALIGN(FORCE_STRIDE, 64);
		f = FORCE_FORMAT;
	}

	flg = kzalloc(sizeof(*flg), GFP_KERNEL);
	if (!flg) {
		VEHICLE_DGERR("flinger is NULL\n");
		return -ENOMEM;
	}

	if (!flg->drm_dev)
		flg->drm_dev = rockchip_drm_get_dev();
	if (!flg->drm_dev) {
		VEHICLE_DGERR("------drm device is not ready!!!-----\n");
		kfree(flg);
		return -ENODEV;
	}

	mutex_init(&flg->queue_buffer_lock);
	mutex_init(&flg->source_buffer_lock);
	mutex_init(&flg->target_buffer_lock);
	INIT_LIST_HEAD(&flg->queue_buffer_list);
	init_waitqueue_head(&flg->worker_wait);
	atomic_set(&flg->worker_cond_atomic, 0);
	atomic_set(&flg->worker_running_atomic, 1);

	for (i = 0; i < NUM_SOURCE_BUFFERS; i++) {
		flg->source_buffer[i].handle = 0;
		flg->source_buffer[i].phy_addr = 0;
		flg->source_buffer[i].fd = -1;
	}
	for (i = 0; i < NUM_TARGET_BUFFERS; i++) {
		flg->target_buffer[i].phy_addr = 0;
		flg->target_buffer[i].handle = 0;
		flg->target_buffer[i].fd = -1;
	}

	for (i = 0; i < NUM_SOURCE_BUFFERS; i++) {
		buffer = &(flg->source_buffer[i]);
		ret = rk_flinger_alloc_buffer(flg, buffer, w, h, s, f);
		if (ret) {
			VEHICLE_DGERR("rk_flinger alloc src buffer failed(%d)\n",
					ret);
			goto free_dst_alloc;
		}
		buffer->state = FREE;
	}
	for (i = 0; i < NUM_TARGET_BUFFERS; i++) {
		buffer = &(flg->target_buffer[i]);
		// f = HAL_PIXEL_FORMAT_RGBX_8888;
		// if (FORCE_ROTATION == RGA_TRANSFORM_ROT_270 ||
		//	FORCE_ROTATION == RGA_TRANSFORM_ROT_90)
		if ((v_cfg->rotate_mirror & RGA_TRANSFORM_ROT_MASK) == 0x01 ||
		    (v_cfg->rotate_mirror & RGA_TRANSFORM_ROT_MASK) == 0x04)
			ret = rk_flinger_alloc_buffer(flg, buffer, h, w, s, f);
		else
			ret = rk_flinger_alloc_buffer(flg, buffer, w, h, s, f);
		// ret = rk_flinger_alloc_buffer(flg, buffer, w, h, s, f);
		if (ret) {
			VEHICLE_DGERR("rk_flinger alloc dst buffer failed\n");
			goto free_src_alloc;
		}
		buffer->state = FREE;
	}

	ret = rk_flinger_create_worker(flg);
	if (ret) {
		VEHICLE_DGERR("rk_flinger create worker failed\n");
		goto free_dst_alloc;
	}
	flinger = flg;

	memcpy(&flg->v_cfg, v_cfg, sizeof(struct vehicle_cfg));
	rk_flinger_queue_work(flg, NULL);
	flg->dev = dev;

	ret = vehicle_flinger_parse_dt(flg);
	if (ret) {
		VEHICLE_DGERR("vehicle flinger parse dts failed\n");
		goto free_dst_alloc;
	}

	VEHICLE_INFO("vehicle flinger init ok\n");
	inited = true;

	return 0;
free_dst_alloc:
	for (i = 0; i < NUM_TARGET_BUFFERS; i++)
		rk_flinger_free_buffer(flg, &(flg->target_buffer[i]));

free_src_alloc:
	for (i = 0; i < NUM_SOURCE_BUFFERS; i++)
		rk_flinger_free_buffer(flg, &(flg->source_buffer[i]));

	return -EINVAL;
}
__maybe_unused int vehicle_flinger_deinit(void)
{
	struct flinger *flg = flinger;
	int i;

	if (!flg)
		return -ENODEV;

	atomic_set(&flg->worker_running_atomic, 0);
	atomic_inc(&flg->worker_cond_atomic);
	wake_up(&flg->worker_wait);
	flush_work(&flg->render_work);
	flush_workqueue(flg->render_workqueue);
	rk_flinger_destroy_worker(flg);

	flinger = NULL;
	for (i = 0; i < NUM_SOURCE_BUFFERS; i++)
		rk_flinger_free_buffer(flg, &flg->source_buffer[i]);

	for (i = 0; i < NUM_TARGET_BUFFERS; i++)
		rk_flinger_free_buffer(flg, &flg->target_buffer[i]);

	kfree(flg);

	return 0;
}

static int rk_flinger_format_hal_to_rga(int format)
{
	int rga_format = -1;

	switch (format) {
	case HAL_PIXEL_FORMAT_RGB_565:
		rga_format =  RGA_FORMAT_RGB_565;
		break;
	case HAL_PIXEL_FORMAT_RGB_888:
		rga_format =  RGA_FORMAT_RGB_888;
		break;
	case HAL_PIXEL_FORMAT_RGBA_8888:
		rga_format =  RGA_FORMAT_RGBA_8888;
		break;
	case HAL_PIXEL_FORMAT_RGBX_8888:
		rga_format =  RGA_FORMAT_RGBX_8888;
		break;
	case HAL_PIXEL_FORMAT_BGRA_8888:
		rga_format =  RGA_FORMAT_BGRA_8888;
		break;
	case HAL_PIXEL_FORMAT_YCrCb_NV12:
		rga_format =  RGA_FORMAT_YCrCb_420_SP;
		break;
	case HAL_PIXEL_FORMAT_YCbCr_422_SP:
		rga_format =  RGA_FORMAT_YCbCr_422_SP;
		break;
	default:
		break;
	}

	return rga_format;
}

static int rk_flinger_set_rect(struct rect *rect, int x, size_t y,
			       int w, int h, int s, int f)
{
	if (!rect)
		return -EINVAL;

	rect->x = x;
	rect->y = y;
	rect->w = w;
	rect->h = h;
	rect->s = s;
	rect->f = f;

	return 0;
}

static int
rk_flinger_set_buffer_rotation(struct graphic_buffer *buffer, int r)
{
	if (!buffer)
		return -EINVAL;

	buffer->rotation = r;

	return buffer->rotation;
}

static int
rk_flinger_cacultae_dst_rect_by_rotation(struct graphic_buffer *buffer)
{
	struct rect *src_rect, *dst_rect;

	if (!buffer)
		return -EINVAL;

	src_rect = &buffer->src;
	dst_rect = &buffer->dst;

	switch (buffer->rotation & RGA_TRANSFORM_ROT_MASK) {
	case RGA_TRANSFORM_ROT_90:
	case RGA_TRANSFORM_ROT_270:
		dst_rect->x = src_rect->x;
		dst_rect->y = src_rect->y;
		dst_rect->h = src_rect->w;
		dst_rect->w = src_rect->h;
		dst_rect->s = src_rect->h;
		break;
	case RGA_TRANSFORM_ROT_0:
	case RGA_TRANSFORM_ROT_180:
	case RGA_TRANSFORM_FLIP_H:
	case RGA_TRANSFORM_FLIP_V:
	default:
		dst_rect->x = src_rect->x;
		dst_rect->y = src_rect->y;
		dst_rect->w = src_rect->w;
		dst_rect->h = src_rect->h;
		dst_rect->s = src_rect->s;
		break;
	}

	return 0;
}

static int rk_flinger_fill_buffer_rects(struct graphic_buffer *buffer,
					struct rect *src_rect,
					struct rect *dst_rect)
{
	if (!buffer)
		return -EINVAL;

	if (src_rect)
		memcpy(&buffer->src, src_rect, sizeof(struct rect));
	if (dst_rect)
		memcpy(&buffer->dst, dst_rect, sizeof(struct rect));

	return 0;
}

static int rk_flinger_iep_deinterlace(struct flinger *flinger,
				      struct graphic_buffer *src_buffer,
				      struct graphic_buffer *dst_buffer)
{
	struct rga_req rga_request;
	int ret;

	memset(&rga_request, 0, sizeof(rga_request));

	if (!src_buffer || !dst_buffer)
		return -EINVAL;

	rga_request.rotate_mode = 0;
	rga_request.sina = 0;
	rga_request.cosa = 0;

	rga_request.src.act_w = src_buffer->src.w;
	rga_request.src.act_h = src_buffer->src.h;
	rga_request.src.x_offset = 0;
	rga_request.src.y_offset = 0;
	rga_request.src.vir_w = src_buffer->src.w;
	rga_request.src.vir_h = src_buffer->src.h;
	rga_request.src.yrgb_addr = src_buffer->fd;
	rga_request.src.uv_addr = 0;
	rga_request.src.v_addr = 0;
	rga_request.src.format = RGA_FORMAT_YCrCb_420_SP;
	if (src_buffer->rotation == RGA_TRANSFORM_ROT_0 ||
		src_buffer->rotation == RGA_TRANSFORM_ROT_180) {
		rga_request.dst.act_w = src_buffer->src.w;
		rga_request.dst.act_h = src_buffer->src.h / 2;
		rga_request.dst.vir_w = src_buffer->src.w;
		rga_request.dst.vir_h = src_buffer->src.h / 2;
	} else {
		rga_request.dst.act_w = src_buffer->src.w / 2;
		rga_request.dst.act_h = src_buffer->src.h;
		rga_request.dst.vir_w = src_buffer->src.w / 2;
		rga_request.dst.vir_h = src_buffer->src.h;
	}
	rga_request.dst.x_offset = 0;
	rga_request.dst.y_offset = 0;

	rga_request.dst.yrgb_addr = dst_buffer->fd;
	rga_request.dst.uv_addr = 0;
	rga_request.dst.v_addr = 0;
	rga_request.dst.format = RGA_FORMAT_YCrCb_420_SP;

	rga_request.scale_mode = 1;

	rga_request.mmu_info.mmu_en = 1;
	rga_request.mmu_info.mmu_flag = ((2 & 0x3) << 4) |
			 1 | (1 << 31 | 1 << 8 | 1 << 10);

	rga_request.src.rd_mode = RGA_RASTER_MODE;
	rga_request.dst.rd_mode = RGA_RASTER_MODE;

	ret = rga_kernel_commit(&rga_request);
	if (ret)
		VEHICLE_DGERR("RGA_BLIT_SYNC failed(%d)\n", ret);

	dst_buffer->width = src_buffer->width;
	dst_buffer->height = src_buffer->height;
	dst_buffer->src.f = src_buffer->src.f;

	if (src_buffer->rotation == RGA_TRANSFORM_ROT_0 ||
		src_buffer->rotation == RGA_TRANSFORM_ROT_180) {
		dst_buffer->src.w = src_buffer->src.w;
		dst_buffer->src.h = src_buffer->src.h / 2;
	} else {
		dst_buffer->src.w = src_buffer->src.w / 2;
		dst_buffer->src.h = src_buffer->src.h;
	}
	dst_buffer->src.x = 0;
	dst_buffer->src.y = 0;

	src_buffer->state = FREE;

	return 0;
}

static int rk_flinger_rga_scaler(struct flinger *flinger,
				 struct graphic_buffer *src_buffer,
				 struct graphic_buffer *dst_buffer)
{
	struct rga_req rga_request;
	int ret;

	memset(&rga_request, 0, sizeof(rga_request));

	if (!src_buffer || !dst_buffer)
		return -EINVAL;

	rga_request.rotate_mode = 0;
	rga_request.sina = 0;
	rga_request.cosa = 0;

	rga_request.yuv2rgb_mode = 0x0 << 0; // yuvtoyuv config 0
	/* yuv to rgb color space transform if need  */
	//rga_request.yuv2rgb_mode = 0x1 << 0; // limit range
	//rga_request.yuv2rgb_mode = 0x2 << 0; // full range

	rga_request.src.act_w = src_buffer->src.w;
	rga_request.src.act_h = src_buffer->src.h;
	rga_request.src.x_offset = 0;
	rga_request.src.y_offset = 0;
	rga_request.src.vir_w = src_buffer->src.w;
	rga_request.src.vir_h = src_buffer->src.h;
	rga_request.src.yrgb_addr = src_buffer->fd;
	rga_request.src.uv_addr = 0;
	rga_request.src.v_addr = 0;
	rga_request.src.format = RGA_FORMAT_YCrCb_420_SP;

	rga_request.dst.act_w = dst_buffer->width;
	rga_request.dst.act_h = dst_buffer->height;
	rga_request.dst.x_offset = 0;
	rga_request.dst.y_offset = 0;
	rga_request.dst.vir_w = dst_buffer->width;
	rga_request.dst.vir_h = dst_buffer->height;
	rga_request.dst.yrgb_addr = dst_buffer->fd;
	rga_request.dst.uv_addr = 0;
	rga_request.dst.v_addr = 0;
	rga_request.dst.format =  RGA_FORMAT_YCrCb_420_SP;

	rga_request.scale_mode = 1;

	rga_request.mmu_info.mmu_en = 1;
	rga_request.mmu_info.mmu_flag = ((2 & 0x3) << 4) |
		   1 | (1 << 31 | 1 << 8 | 1 << 10);

	rga_request.src.rd_mode = RGA_RASTER_MODE;
	rga_request.dst.rd_mode = RGA_RASTER_MODE;

	ret = rga_kernel_commit(&rga_request);
	if (ret)
		VEHICLE_DGERR("RGA_BLIT_SYNC failed(%d)\n", ret);

	dst_buffer->src.f = dst_buffer->format;
	dst_buffer->src.w = dst_buffer->width;
	dst_buffer->src.h = dst_buffer->height;
	dst_buffer->src.x = 0;
	dst_buffer->src.y = 0;
	/* save rga in buffer */
	if (vehicle_dump_rga) {
		struct file *filep = NULL;
		loff_t pos = 0;
		static bool file_ready;
		static int frame_count;

		VEHICLE_DG("@%s src->vir_addr[0](%d) addr[100](%d)\n",
				__func__, ((char *)(src_buffer->vir_addr))[0],
					((char *)(src_buffer->vir_addr))[100]);
		if (!file_ready) {
			int frame_len = src_buffer->src.w * src_buffer->src.h * 3 / 2;
			char path[128] = {0};
			mm_segment_t fs;

			VEHICLE_DG("save vop frame(%d) frame_len(%d)\n",
							frame_count++, frame_len);
			sprintf(path, "/data/rga_scaler_in_%zu_%zu.yuv",
					src_buffer->src.w, src_buffer->src.h);
			filep = filp_open(path, O_CREAT | O_RDWR, 0666);
			if (IS_ERR(filep)) {
				VEHICLE_DGERR(" %s filp_open failed!\n", path);
				file_ready = false;
			} else {
				fs = get_fs();
				set_fs(KERNEL_DS);
				vfs_write(filep,
					(unsigned char __user *)(src_buffer->vir_addr),
					frame_len, &pos);
				filp_close(filep, NULL);
				set_fs(fs);
				VEHICLE_INFO(" %s file saved ok!\n", path);
				file_ready = true;
			}
		}
	}
	/* save rga out buffer */
	if (vehicle_dump_rga) {
		struct file *filep = NULL;
		loff_t pos = 0;
		static bool file_ready;
		static int frame_count;

		VEHICLE_DG("@%s dst->vir_addr[0](%d) addr[100](%d)\n",
				__func__, ((char *)(dst_buffer->vir_addr))[0],
					((char *)(dst_buffer->vir_addr))[100]);
		if (!file_ready) {
			/* NV12 */
			int frame_len = dst_buffer->src.w * dst_buffer->src.h * 3 / 2;
			char path[128] = {0};
			mm_segment_t fs;

			VEHICLE_DG("save vop frame(%d) frame_len(%d)\n",
							frame_count++, frame_len);
			sprintf(path, "/data/rga_scaler_out_%zu_%zu.yuv",
					dst_buffer->src.w, dst_buffer->src.h);
			filep = filp_open(path, O_CREAT | O_RDWR, 0666);
			if (IS_ERR(filep)) {
				VEHICLE_DGERR(" %s filp_open failed!\n", path);
				file_ready = false;
			} else {
				fs = get_fs();
				set_fs(KERNEL_DS);
				vfs_write(filep,
					(unsigned char __user *)(dst_buffer->vir_addr),
					frame_len, &pos);
				filp_close(filep, NULL);
				set_fs(fs);
				VEHICLE_INFO(" %s file saved ok!\n", path);
				file_ready = true;
			}
		}
	}

	src_buffer->state = FREE;

	return 0;
}

static int rk_flinger_rga_blit(struct flinger *flinger,
			       struct graphic_buffer *src_buffer,
			       struct graphic_buffer *dst_buffer)
{
	struct rga_req rga_request;
	int sx, sy, sw, sh, ss, sf;
	int dx, dy, dw, dh, ds, df;
	int orientation;
	int ret;
	int src_fd, dst_fd;

	if (!src_buffer || !dst_buffer)
		return -EINVAL;

	src_fd = src_buffer->fd;
	dst_fd = dst_buffer->fd;

	memset(&rga_request, 0, sizeof(rga_request));

	orientation = src_buffer->rotation;
	dst_buffer->rotation = src_buffer->rotation;

	sx = src_buffer->src.x;
	sy = src_buffer->src.y;
	sw = src_buffer->src.w;
	ss = src_buffer->src.s;
	sh = src_buffer->src.h;
	sf = rk_flinger_format_hal_to_rga(src_buffer->src.f);
	VEHICLE_DG("%s src: sx:%d, sy:%d, sw:%d, ss:%d, sh:%d\n",
				__func__, sx, sy, sw, ss, sh);
	dx = src_buffer->dst.x;
	dy = src_buffer->dst.y;
	dw = src_buffer->dst.w;
	ds = src_buffer->dst.s;
	dh = src_buffer->dst.h;
	df = rk_flinger_format_hal_to_rga(src_buffer->dst.f);
	VEHICLE_DG("%s dst: dx:%d, dy:%d, dw:%d, ds:%d, dh:%d\n",
				__func__, dx, dy, dw, ds, dh);
	if (src_buffer->offset) {
		sh += src_buffer->offset / src_buffer->len * sh;
		sx = src_buffer->offset / src_buffer->len * sh;
		src_fd = 0;
	}
	VEHICLE_DG("%s src: sx:%d, sy:%d, sw:%d, ss:%d, sh:%d\n",
				__func__, sx, sy, sw, ss, sh);
	switch (orientation) {
	case RGA_TRANSFORM_ROT_0:
		rga_request.rotate_mode = 0;
		rga_request.sina = 0;
		rga_request.cosa = 0;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dw;
		rga_request.dst.act_h = dh;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	case RGA_TRANSFORM_FLIP_H:/*x mirror*/
		rga_request.rotate_mode = 2;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dw;
		rga_request.dst.act_h = dh;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	case RGA_TRANSFORM_FLIP_V:/*y mirror*/
		rga_request.rotate_mode = 3;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dw;
		rga_request.dst.act_h = dh;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	case RGA_TRANSFORM_ROT_90:
		rga_request.rotate_mode = 1;
		rga_request.sina = 65536;
		rga_request.cosa = 0;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dh;
		rga_request.dst.act_h = dw;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	case RGA_TRANSFORM_ROT_180:
		rga_request.rotate_mode = 1;
		rga_request.sina = 0;
		rga_request.cosa = -65536;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dw;
		rga_request.dst.act_h = dh;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	case RGA_TRANSFORM_ROT_270:
		rga_request.rotate_mode = 1;
		rga_request.sina = -65536;
		rga_request.cosa = 0;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dh;
		rga_request.dst.act_h = dw;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	default:
		rga_request.rotate_mode = 0;
		rga_request.sina = 0;
		rga_request.cosa = 0;
		rga_request.dst.vir_w = ds;
		rga_request.dst.vir_h = dh;
		rga_request.dst.act_w = dw;
		rga_request.dst.act_h = dh;
		rga_request.dst.x_offset = 0;
		rga_request.dst.y_offset = 0;
		break;
	}

	rga_request.src.yrgb_addr = src_fd;
	rga_request.src.uv_addr = 0;
	rga_request.src.v_addr = 0;

	rga_request.dst.yrgb_addr = dst_fd;
	rga_request.dst.uv_addr = 0;
	rga_request.dst.v_addr = 0;

	rga_request.src.vir_w = ss;
	rga_request.src.vir_h = sh;
	rga_request.src.format = sf;
	rga_request.src.act_w = sw;
	rga_request.src.act_h = sh;
	rga_request.src.x_offset = 0;
	rga_request.src.y_offset = 0;

	rga_request.dst.format = df;

	rga_request.clip.xmin = 0;
	rga_request.clip.xmax = dw - 1;
	rga_request.clip.ymin = 0;
	rga_request.clip.ymax = dh - 1;
	rga_request.scale_mode = 0;

	rga_request.yuv2rgb_mode = 0x0 << 0; // yuvtoyuv config 0
	/* yuv to rgb color space transform if need  */
	//rga_request.yuv2rgb_mode = 0x1 << 0; // limit range
	//rga_request.yuv2rgb_mode = 0x2 << 0; // full range

	rga_request.mmu_info.mmu_en = 1;
	rga_request.mmu_info.mmu_flag = ((2 & 0x3) << 4) |
		 1 | (1 << 31 | 1 << 8 | 1 << 10);

	rga_request.src.rd_mode = RGA_RASTER_MODE;
	rga_request.dst.rd_mode = RGA_RASTER_MODE;

	VEHICLE_DG("%s src_buffer->src.f(%zu) src_buffer->dst.f(%zu)",
				__func__, src_buffer->src.f, src_buffer->dst.f);
	ret = rga_kernel_commit(&rga_request);
	if (ret)
		VEHICLE_DGERR("RGA_BLIT_SYNC failed(%d)\n", ret);

	return 0;
}

static int rk_flinger_rga_render(struct flinger *flinger,
				 struct graphic_buffer *src_buffer,
				 struct graphic_buffer *dst_buffer,
				 struct graphic_buffer *tmp_buffer)
{
	int rotation;

	if (!flinger || !src_buffer || !dst_buffer)
		return -EINVAL;

	if (dst_buffer && dst_buffer->rel_fence)
		dst_buffer->rel_fence = NULL;

	if ((src_buffer->rotation & RGA_TRANSFORM_ROT_MASK) &&
		(src_buffer->rotation & RGA_TRANSFORM_FLIP_MASK)) {

		rotation = flinger->v_cfg.rotate_mirror;
		/* 1. rotate */
		src_buffer->rotation = rotation & RGA_TRANSFORM_ROT_MASK;
		rk_flinger_rga_blit(flinger, src_buffer, tmp_buffer);
		rk_flinger_fill_buffer_rects(tmp_buffer, &src_buffer->dst,
					     &src_buffer->dst);
		tmp_buffer->src.f = src_buffer->dst.f;
		tmp_buffer->rotation = rotation & RGA_TRANSFORM_FLIP_MASK;
		/* 2. mirror */
		rk_flinger_rga_blit(flinger, tmp_buffer, dst_buffer);
		rk_flinger_fill_buffer_rects(dst_buffer, &tmp_buffer->dst,
					     &tmp_buffer->dst);
		dst_buffer->src.f = src_buffer->dst.f;

		src_buffer->rotation = rotation;
	} else {
		rk_flinger_rga_blit(flinger, src_buffer, dst_buffer);
		rk_flinger_fill_buffer_rects(dst_buffer, &src_buffer->dst,
					     &src_buffer->dst);
		dst_buffer->src.f = src_buffer->dst.f;
	}
	/* save rga out buffer */
	if (vehicle_dump_rga) {
		struct file *filep = NULL;
		loff_t pos = 0;
		static bool file_ready;
		static int frame_count;

		VEHICLE_DG("@%s dst->vir_addr[0](%d) addr[100](%d)\n",
				__func__, ((char *)(dst_buffer->vir_addr))[0],
					((char *)(dst_buffer->vir_addr))[100]);
		if (!file_ready) {
			int frame_len = dst_buffer->src.w * dst_buffer->src.h * 3 / 2;//NV12
			char path[128] = {0};
			mm_segment_t fs;

			VEHICLE_DG("save vop frame(%d) frame_len(%d)\n",
							frame_count++, frame_len);
			sprintf(path, "/data/rga_render_%zu_%zu.yuv",
					dst_buffer->src.w, dst_buffer->src.h);
			filep = filp_open(path, O_CREAT | O_RDWR, 0666);
			if (IS_ERR(filep)) {
				VEHICLE_DGERR(" %s filp_open failed!\n", path);
				file_ready = false;
			} else {
				fs = get_fs();
				set_fs(KERNEL_DS);
				vfs_write(filep,
					(unsigned char __user *)(dst_buffer->vir_addr),
					frame_len, &pos);
				filp_close(filep, NULL);
				set_fs(fs);
				VEHICLE_INFO(" %s file saved ok!\n", path);
				file_ready = true;
			}
		}
	}

	return 0;
}

static void rk_drm_vehicle_commit(struct flinger *flinger, struct graphic_buffer *buffer)
{
	struct rockchip_drm_direct_show_commit_info commit_info;
	int hdisplay = flinger->crtc->state->adjusted_mode.hdisplay;
	int vdisplay = flinger->crtc->state->adjusted_mode.vdisplay;

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

	commit_info.src_x = 0;
	commit_info.src_y = 0;
	commit_info.src_w = buffer->src.w;
	commit_info.src_h = buffer->src.h;
	// commit_info.src_w = buffer->drm_buffer->width;
	// commit_info.src_h = buffer->drm_buffer->height;

	/*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;

	/*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.top_zpos  = true;

	commit_info.buffer = buffer->drm_buffer;

	if (vehicle_dump_vop) {
		struct file *filep = NULL;
		loff_t pos = 0;
		static bool file_ready;
		static int frame_count;

		if (!file_ready) {
			int frame_len = buffer->drm_buffer->width *
					buffer->drm_buffer->height * 3 / 2;//NV12
			char path[128] = {0};
			mm_segment_t fs;

			VEHICLE_DG("save vop frame(%d) frame_len(%d)\n",
							frame_count++, frame_len);
			sprintf(path, "/data/vop_commit_%d_%d.yuv",
						buffer->drm_buffer->width,
						buffer->drm_buffer->height);
			filep = filp_open(path, O_CREAT | O_RDWR, 0666);
			if (IS_ERR(filep)) {
				VEHICLE_DGERR(" %s filp_open failed!\n", path);
				file_ready = false;
			} else {
				fs = get_fs();
				set_fs(KERNEL_DS);
				vfs_write(filep,
					(unsigned char __user *)(buffer->drm_buffer->vir_addr[0]),
					frame_len, &pos);
				filp_close(filep, NULL);
				set_fs(fs);
				VEHICLE_INFO(" %s file saved ok!\n", path);
				file_ready = true;
			}
		}
	}
	rockchip_drm_direct_show_commit(flinger->drm_dev, &commit_info);
}

static int drop_frames_number;
static int rk_flinger_vop_show(struct flinger *flinger,
			       struct graphic_buffer *buffer)
{
	if (!flinger || !buffer)
		return -EINVAL;

	VEHICLE_DG("flinger vop show buffer wxh(%zux%zu)\n",
					buffer->src.w, buffer->src.h);
	if (drop_frames_number > 0) {
		VEHICLE_INFO("%s discard the frame num(%d)!\n", __func__, drop_frames_number);
		drop_frames_number--;
		return 0;
	}

	if (!flinger->running)
		return 0;

	/* get crtc and plane */
	flinger->crtc = rockchip_drm_direct_show_get_crtc(flinger->drm_dev, flinger->crtc_name);
	if (flinger->crtc == NULL) {
		VEHICLE_DGERR("error: failed to get crtc\n");
		return -EINVAL;
	}

	flinger->plane = rockchip_drm_direct_show_get_plane(flinger->drm_dev, flinger->plane_name);
	if (flinger->plane == NULL) {
		VEHICLE_DGERR("error: failed to get plane\n");
		return -EINVAL;
	}

	rk_drm_vehicle_commit(flinger, buffer);

	flinger->debug_vop_count++;
	/* save vop show buffer */
	if (vehicle_dump_vop) {
		struct file *filep = NULL;
		loff_t pos = 0;
		static bool file_ready;
		static int frame_count;

		VEHICLE_DG("@%s buffer->vir_addr[0](%d) addr[100](%d)\n",
				__func__, ((char *)(buffer->vir_addr))[0],
					((char *)(buffer->vir_addr))[100]);
		if (!file_ready) {
			int frame_len = buffer->src.w * buffer->src.h * 3 / 2;//NV12
			char path[128] = {0};
			mm_segment_t fs;

			VEHICLE_DG("save vop frame(%d) frame_len(%d)\n",
							frame_count++, frame_len);
			sprintf(path, "/data/vop_show_%zu_%zu.yuv",
						buffer->src.w, buffer->src.h);
			filep = filp_open(path, O_CREAT | O_RDWR, 0666);
			if (IS_ERR(filep)) {
				VEHICLE_DGERR(" %s filp_open failed!\n", path);
				file_ready = false;
			} else {
				fs = get_fs();
				set_fs(KERNEL_DS);
				vfs_write(filep,
					(unsigned char __user *)(buffer->vir_addr),
					frame_len, &pos);
				filp_close(filep, NULL);
				set_fs(fs);
				VEHICLE_INFO(" %s file saved ok!\n", path);
				file_ready = true;
			}
		}
	}

	return 0;
}

static void rk_flinger_first_done(struct work_struct *work)
{
	struct graphic_buffer *buffer;
	struct flinger *flg = flinger;
	int i;
	struct flinger *flg_test =
		 container_of(work, struct flinger, init_work);
	struct vehicle_cfg *v_cfg = &flg_test->v_cfg;

	if (!flg)
		return;

	for (i = 0; i < NUM_SOURCE_BUFFERS; i++) {
		if (flg->source_buffer[i].state == FREE) {
			buffer = &(flg->source_buffer[i]);
			rk_flinger_set_rect(&buffer->src,
					    FORCE_XOFFSET, FORCE_YOFFSET,
					    v_cfg->width, v_cfg->height,
					    v_cfg->width, FORCE_FORMAT);
			rk_flinger_set_buffer_rotation(buffer, v_cfg->rotate_mirror);
			rk_flinger_cacultae_dst_rect_by_rotation(buffer);
			buffer->dst.f = buffer->src.f;
			VEHICLE_INFO("buffer[%d]->rotation(%d).\n",
				      i, buffer->rotation);
		}
	}
}

static void rk_flinger_render_show(struct work_struct *work)
{
	struct graphic_buffer *src_buffer, *dst_buffer, *iep_buffer, *buffer;
	/* struct queue_buffer *cur = NULL, *next = NULL; */
	struct flinger *flg = flinger;
	int i, found = 0;
	static int count = -1;
	static int last_src_index = -1;
	bool cvbs_flag = true;
	struct flinger *flg_test =
			container_of(work, struct flinger, render_work);
	struct vehicle_cfg *v_cfg = &flg_test->v_cfg;

	src_buffer = NULL;
	dst_buffer = NULL;
	flg->source_index = 0;

	do {
try_again:
		wait_event_interruptible_timeout(flg->worker_wait,
						 atomic_read(&flg->worker_cond_atomic),
						 msecs_to_jiffies(1000000));
		VEHICLE_DG("wake up enter, v_cfg.w*h(%dx%d)\n",
				v_cfg->width, v_cfg->height);

		if (atomic_read(&flg->worker_running_atomic) == 0) {
			VEHICLE_INFO("%s loop exit\n", __func__);
			break;
		}
		if (atomic_read(&flg->worker_cond_atomic) <= 0) {
			/*printk("waiting 'worker_cond_atomic' timed out.");*/
			goto try_again;
		}
		atomic_dec(&flg->worker_cond_atomic);

		/*  1. find src buffer */
		src_buffer = NULL;
		found = last_src_index + 1;
		for (i = 1; i < NUM_SOURCE_BUFFERS; i++, found++) {
			found = found % NUM_SOURCE_BUFFERS;
			if (flg->source_buffer[found].state == QUEUE) {
				src_buffer = &flg->source_buffer[found];
				last_src_index = found;
				break;
			}
		}

		if (!src_buffer || !src_buffer->fd) {
			usleep_range(3000, 3100);
			VEHICLE_DGERR("[%s:%d] error, no buffer\n", __func__, __LINE__);
			goto try_again;
		}

		count++;
		src_buffer->state = ACQUIRE;
		/* save rkcif buffer */
		if (vehicle_dump_cif) {
			// struct file *filep = NULL;
			struct file *filep;
			loff_t pos = 0;
			static bool file_ready;
			static int frame_count;

			VEHICLE_DG("src_buffer->vir_addr[0](%d) addr[100](%d)\n",
						((char *)(src_buffer->vir_addr))[0],
						((char *)(src_buffer->vir_addr))[100]);

			if (!file_ready) {
				//nv12 frame_len=w*h*3/2
				int frame_len = src_buffer->src.w * src_buffer->src.h * 3 / 2;
				char path[128] = {0};
				mm_segment_t fs;

				VEHICLE_DG("save vop frame(%d) frame_len(%d)\n",
								frame_count++, frame_len);
				sprintf(path, "/data/cif_out_%zu_%zu.yuv",
							src_buffer->src.w, src_buffer->src.h);
				filep = filp_open(path, O_RDWR | O_CREAT, 0666);
				if (IS_ERR(filep)) {
					VEHICLE_DGERR(" %s filp_open failed!\n", path);
					file_ready = false;
				} else {
					fs = get_fs();
					set_fs(KERNEL_DS);
					vfs_write(filep, src_buffer->vir_addr, frame_len, &pos);
					filp_close(filep, NULL);
					set_fs(fs);
					VEHICLE_INFO(" %s file saved ok!\n", path);
					file_ready = true;
				}
			}
		}

		/*  2. find dst buffer */
		dst_buffer = NULL;
		iep_buffer = NULL;
		/*get iep, rga, vop buffer*/
		if (1) { //rotation by rga
			if (flg->v_cfg.input_format == CIF_INPUT_FORMAT_PAL ||
			    flg->v_cfg.input_format == CIF_INPUT_FORMAT_NTSC) {
				iep_buffer = &(flg->target_buffer
					       [NUM_TARGET_BUFFERS - 1]);
				iep_buffer->state = ACQUIRE;
				cvbs_flag = true;
			} else {
				cvbs_flag = false;
			}
			dst_buffer = &(flg->target_buffer
				       [count % (NUM_TARGET_BUFFERS - 1)]);
			dst_buffer->state = ACQUIRE;
		} else if (flg->v_cfg.input_format == CIF_INPUT_FORMAT_PAL ||
			   flg->v_cfg.input_format == CIF_INPUT_FORMAT_NTSC) {
			iep_buffer = &(flg->target_buffer
				       [count % NUM_TARGET_BUFFERS]);
			iep_buffer->state = ACQUIRE;
		}
		if (!iep_buffer || !iep_buffer->fd) {
			if (iep_buffer)
				iep_buffer->state = FREE;
		}

		/* 3 do deinterlace & rotation & display*/
		if (!cvbs_flag) {
			// YPbPr
			VEHICLE_DG("it is ypbpr signal\n");
			iep_buffer = &(flg->target_buffer[NUM_TARGET_BUFFERS - 1]);
			iep_buffer->state = ACQUIRE;
			//scaler by rga to force widthxheight display
			rk_flinger_rga_render(flg, src_buffer, iep_buffer, dst_buffer);
			src_buffer->state = FREE;
			rk_flinger_rga_scaler(flg, iep_buffer, dst_buffer);
			iep_buffer->state = FREE;
			rk_flinger_vop_show(flg, dst_buffer);
			for (i = 0; i < NUM_TARGET_BUFFERS; i++) {
				buffer = &(flinger->target_buffer[i]);
				if (buffer->state == DISPLAY)
					buffer->state = FREE;
			}

			dst_buffer->state = DISPLAY;
		} else {
			// cvbs
			VEHICLE_DG("it is a cvbs signal\n");
			rk_flinger_rga_render(flg, src_buffer, dst_buffer, iep_buffer);
			src_buffer->state = FREE;
			rk_flinger_iep_deinterlace(flg, dst_buffer, iep_buffer);
			dst_buffer->state = FREE;
			rk_flinger_rga_scaler(flg, iep_buffer, dst_buffer);
			rk_flinger_vop_show(flg, dst_buffer);
			iep_buffer->state = FREE;

			for (i = 0; i < NUM_TARGET_BUFFERS; i++) {
				buffer = &(flinger->target_buffer[i]);
				if (buffer->state == DISPLAY)
					buffer->state = FREE;
			}
			dst_buffer->state = DISPLAY;
		}
	} while (1);
}

static int rk_flinger_queue_work(struct flinger *flinger,
				 struct graphic_buffer *src_buffer)
{
	if (!flinger)
		return -ENODEV;

	if (!src_buffer) {
		if (flinger->render_workqueue) {
			INIT_WORK(&flinger->init_work, rk_flinger_first_done);
			queue_work(flinger->render_workqueue,
				   &flinger->init_work);
		}
	}

	if (flinger->render_workqueue) {
		INIT_WORK(&flinger->render_work, rk_flinger_render_show);
		queue_work(flinger->render_workqueue, &flinger->render_work);
	}

	return 0;
}

static struct graphic_buffer *
rk_flinger_lookup_buffer_by_phy_addr(unsigned long phy_addr)
{
	struct graphic_buffer *buffer = NULL;
	struct flinger *flg = flinger;
	int i;

	VEHICLE_DG("%s:phy_addr=%lx\n", __func__, phy_addr);
	for (i = 1; i < NUM_SOURCE_BUFFERS; i++) {
		if (flg->source_buffer[i].state == DEQUEUE) {
			buffer = &(flg->source_buffer[i]);
			if (buffer && (buffer->offset +
			    buffer->phy_addr == phy_addr)) {
				buffer->state = QUEUE;
				break;
			}
		}
	}
	if (i < NUM_SOURCE_BUFFERS)
		return buffer;
	else
		return NULL;
}

static bool vehicle_rotation_param_check(struct vehicle_cfg *v_cfg)
{
	switch (v_cfg->rotate_mirror & RGA_TRANSFORM_ROT_MASK) {
	case RGA_TRANSFORM_ROT_90:
	case RGA_TRANSFORM_ROT_270:
	case RGA_TRANSFORM_ROT_0:
	case RGA_TRANSFORM_ROT_180:
		return true;
	default:
		VEHICLE_INFO("invalid rotate-mirror param %d\n",
					v_cfg->rotate_mirror);
		v_cfg->rotate_mirror = v_cfg->rotate_mirror & RGA_TRANSFORM_FLIP_MASK;
		return false;
	}

	switch (v_cfg->rotate_mirror & RGA_TRANSFORM_FLIP_MASK) {
	case RGA_TRANSFORM_FLIP_H:
	case RGA_TRANSFORM_FLIP_V:
		return true;
	default:
		VEHICLE_INFO("invalid rotate-mirror param %d\n",
					v_cfg->rotate_mirror);
		v_cfg->rotate_mirror = v_cfg->rotate_mirror & RGA_TRANSFORM_ROT_MASK;
		return false;
	}
}
int vehicle_flinger_reverse_open(struct vehicle_cfg *v_cfg,
				bool android_is_ready)
{
	int i;
	int width;
	int height;
	struct flinger *flg = flinger;
	struct graphic_buffer *buffer;
	int hal_format;

	width = v_cfg->width;
	height = v_cfg->height;

	if (!flinger)
		return -ENODEV;

	vehicle_rotation_param_check(v_cfg);

	if (v_cfg->output_format == CIF_OUTPUT_FORMAT_422)
		hal_format = HAL_PIXEL_FORMAT_YCbCr_422_SP;
	else
		hal_format = HAL_PIXEL_FORMAT_YCrCb_NV12;

	/*  1. reinit buffer format */
	for (i = 0; i < NUM_SOURCE_BUFFERS; i++) {
		buffer = &(flg->source_buffer[i]);
		rk_flinger_set_rect(&buffer->src,
				    0, 0, width,
				    height, width, hal_format);
		rk_flinger_set_buffer_rotation(buffer, v_cfg->rotate_mirror);
		rk_flinger_cacultae_dst_rect_by_rotation(buffer);
		buffer->dst.f = buffer->src.f;
		buffer->state = FREE;
	}

	for (i = 0; i < NUM_TARGET_BUFFERS; i++) {
		buffer = &(flg->target_buffer[i]);
		buffer->state = FREE;
	}

	/*2. fill buffer info*/
	for (i = 0; i < NUM_SOURCE_BUFFERS && i < MAX_BUF_NUM; i++) {
		v_cfg->buf_phy_addr[i] = flinger->source_buffer[i].phy_addr;
		VEHICLE_DG("buf_phy_addr=%x, i=%d", v_cfg->buf_phy_addr[i], i);
	}

	v_cfg->buf_num = NUM_SOURCE_BUFFERS;

	flg->cvbs_field_count = 0;
	memcpy(&flg->v_cfg, v_cfg, sizeof(struct vehicle_cfg));
	flg->running = true;
	drop_frames_number = v_cfg->drop_frames;

	return 0;
}

int vehicle_flinger_reverse_close(bool android_is_ready)
{
	struct flinger *flg = flinger;

	flg->running = false;
	if (flg->drm_dev && flg->plane)
		rockchip_drm_direct_show_disable_plane(flg->drm_dev, flg->plane);
	VEHICLE_DG("%s(%d) done\n", __func__, __LINE__);

	return 0;
}

unsigned long vehicle_flinger_request_cif_buffer(void)
{
	struct graphic_buffer *src_buffer = NULL;
	struct flinger *flg = flinger;
	static int last_src_index = -1;
	int found;
	int i;

	src_buffer = NULL;
	for (i = 1; i < NUM_SOURCE_BUFFERS; i++) {
		found = (last_src_index + i) % NUM_SOURCE_BUFFERS;
		VEHICLE_DG("%s,flg->source_buffer[%d].state(%d)",
			__func__, found, flg->source_buffer[found].state);
		if (flg->source_buffer[found].state == FREE) {
			src_buffer = &flg->source_buffer[found];
			last_src_index = found;
			src_buffer->state = DEQUEUE;
			break;
		}
	}

	if (i < NUM_SOURCE_BUFFERS)
		return src_buffer->phy_addr;
	else
		return 0;
}

void vehicle_flinger_commit_cif_buffer(u32 buf_phy_addr)
{
	struct graphic_buffer *buffer = NULL;
	struct flinger *flg = flinger;

	if (!flg)
		return;

	buffer = rk_flinger_lookup_buffer_by_phy_addr(buf_phy_addr);
	if (buffer) {
		buffer->timestamp = ktime_get();
		atomic_inc(&flg->worker_cond_atomic);
		flg->debug_cif_count++;
		wake_up(&flg->worker_wait);
	} else {
		VEHICLE_DGERR("%x, no free buffer\n", buf_phy_addr);
	}
}