drivers/frame_provider/decoder/utils/vdec_ge2d_utils.c - manifest_repos/media_modules - Git at Google

 /*
  * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along
  * with this program; if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  * Description:
  */
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/amlogic/media/ge2d/ge2d.h>
 #include <linux/amlogic/media/canvas/canvas_mgr.h>
 #include "vdec.h"
 #include "vdec_ge2d_utils.h"
 #include "../../../common/chips/decoder_cpu_ver_info.h"

 static u32 vdec_ge2d_debug = 0;

 #ifndef  CONFIG_AMLOGIC_MEDIA_GE2D
 inline struct ge2d_context_s *create_ge2d_work_queue(void) { return NULL; }
 inline int destroy_ge2d_work_queue(struct ge2d_context_s *ge2d_work_queue) { return -1; }
 #endif

 enum videocom_source_type {
 	DECODER_8BIT_NORMAL = 0,
 	DECODER_8BIT_BOTTOM,
 	DECODER_8BIT_TOP,
 	DECODER_10BIT_NORMAL,
 	DECODER_10BIT_BOTTOM,
 	DECODER_10BIT_TOP
 };

 static void vdec_canvas_cache_free(struct vdec_canvas_cache *canche)
 {
 	int i = -1;

 	for (i = 0; i < ARRAY_SIZE(canche->res); i++) {
 		if (canche->res[i].cid > 0) {
 			if (vdec_ge2d_debug)
 				pr_info("canvas-free, name:%s, canvas id:%d\n",
 					canche->res[i].name,
 					canche->res[i].cid);

 			canvas_pool_map_free_canvas(canche->res[i].cid);

 			canche->res[i].cid = 0;
 		}
 	}
 }

 static void vdec_canvas_cache_put(struct vdec_ge2d *ge2d)
 {
 	struct vdec_canvas_cache *canche = &ge2d->canche;

 	mutex_lock(&canche->lock);

 	pr_info("canvas-put, ref:%d\n", canche->ref);

 	canche->ref--;

 	if (canche->ref == 0) {
 		vdec_canvas_cache_free(canche);
 	}

 	mutex_unlock(&canche->lock);
 }

 static int vdec_canvas_cache_get(struct vdec_ge2d *ge2d, char *usr)
 {
 	struct vdec_canvas_cache *canche = &ge2d->canche;
 	int i;

 	mutex_lock(&canche->lock);

 	canche->ref++;

 	for (i = 0; i < ARRAY_SIZE(canche->res); i++) {
 		if (canche->res[i].cid <= 0) {
 			snprintf(canche->res[i].name, 32, "%s-%d", usr, i);
 			canche->res[i].cid =
 				canvas_pool_map_alloc_canvas(canche->res[i].name);
 		}

 		if (vdec_ge2d_debug)
 			pr_info("canvas-alloc, name:%s, canvas id:%d\n",
 				canche->res[i].name,
 				canche->res[i].cid);

 		if (canche->res[i].cid <= 0) {
 			pr_err("canvas-fail, name:%s, canvas id:%d.\n",
 				canche->res[i].name,
 				canche->res[i].cid);

 			mutex_unlock(&canche->lock);
 			goto err;
 		}
 	}

 	if (vdec_ge2d_debug)
 		pr_info("canvas-get, ref:%d\n", canche->ref);

 	mutex_unlock(&canche->lock);
 	return 0;
 err:
 	vdec_canvas_cache_put(ge2d);
 	return -1;
 }

 static int vdec_canvas_cache_init(struct vdec_ge2d *ge2d)
 {
 	ge2d->canche.ref = 0;
 	mutex_init(&ge2d->canche.lock);

 	pr_info("canvas-init, ref:%d\n", ge2d->canche.ref);

 	return 0;
 }

 static int get_source_type(struct vframe_s *vf)
 {
 	enum videocom_source_type ret;
 	int interlace_mode;

 	interlace_mode = vf->type & VIDTYPE_TYPEMASK;

 	if ((vf->bitdepth & BITDEPTH_Y10)  &&
 		(!(vf->type & VIDTYPE_COMPRESS)) &&
 		(get_cpu_type() >= MESON_CPU_MAJOR_ID_TXL)) {
 		if (interlace_mode == VIDTYPE_INTERLACE_TOP)
 			ret = DECODER_10BIT_TOP;
 		else if (interlace_mode == VIDTYPE_INTERLACE_BOTTOM)
 			ret = DECODER_10BIT_BOTTOM;
 		else
 			ret = DECODER_10BIT_NORMAL;
 	} else {
 		if (interlace_mode == VIDTYPE_INTERLACE_TOP)
 			ret = DECODER_8BIT_TOP;
 		else if (interlace_mode == VIDTYPE_INTERLACE_BOTTOM)
 			ret = DECODER_8BIT_BOTTOM;
 		else
 			ret = DECODER_8BIT_NORMAL;
 	}

 	return ret;
 }

 static int get_input_format(struct vframe_s *vf)
 {
 	int format = GE2D_FORMAT_M24_YUV420;
 	enum videocom_source_type soure_type;

 	soure_type = get_source_type(vf);

 	switch (soure_type) {
 	case DECODER_8BIT_NORMAL:
 		if (vf->type & VIDTYPE_VIU_422)
 			format = GE2D_FORMAT_S16_YUV422;
 		else if (vf->type & VIDTYPE_VIU_NV21)
 			format = GE2D_FORMAT_M24_NV21;
 		else if (vf->type & VIDTYPE_VIU_NV12)
 			format = GE2D_FORMAT_M24_NV12;
 		else if (vf->type & VIDTYPE_VIU_444)
 			format = GE2D_FORMAT_S24_YUV444;
 		else
 			format = GE2D_FORMAT_M24_YUV420;
 		break;
 	case DECODER_8BIT_BOTTOM:
 		if (vf->type & VIDTYPE_VIU_422)
 			format = GE2D_FORMAT_S16_YUV422
 				| (GE2D_FORMAT_S16_YUV422B & (3 << 3));
 		else if (vf->type & VIDTYPE_VIU_NV21)
 			format = GE2D_FORMAT_M24_NV21
 				| (GE2D_FORMAT_M24_NV21B & (3 << 3));
 		else if (vf->type & VIDTYPE_VIU_NV12)
 			format = GE2D_FORMAT_M24_NV12
 				| (GE2D_FORMAT_M24_NV12B & (3 << 3));
 		else if (vf->type & VIDTYPE_VIU_444)
 			format = GE2D_FORMAT_S24_YUV444
 				| (GE2D_FORMAT_S24_YUV444B & (3 << 3));
 		else
 			format = GE2D_FORMAT_M24_YUV420
 				| (GE2D_FMT_M24_YUV420B & (3 << 3));
 		break;
 	case DECODER_8BIT_TOP:
 		if (vf->type & VIDTYPE_VIU_422)
 			format = GE2D_FORMAT_S16_YUV422
 				| (GE2D_FORMAT_S16_YUV422T & (3 << 3));
 		else if (vf->type & VIDTYPE_VIU_NV21)
 			format = GE2D_FORMAT_M24_NV21
 				| (GE2D_FORMAT_M24_NV21T & (3 << 3));
 		else if (vf->type & VIDTYPE_VIU_NV12)
 			format = GE2D_FORMAT_M24_NV12
 				| (GE2D_FORMAT_M24_NV12T & (3 << 3));
 		else if (vf->type & VIDTYPE_VIU_444)
 			format = GE2D_FORMAT_S24_YUV444
 				| (GE2D_FORMAT_S24_YUV444T & (3 << 3));
 		else
 			format = GE2D_FORMAT_M24_YUV420
 				| (GE2D_FMT_M24_YUV420T & (3 << 3));
 		break;
 	case DECODER_10BIT_NORMAL:
 		if (vf->type & VIDTYPE_VIU_422) {
 			if (vf->bitdepth & FULL_PACK_422_MODE)
 				format = GE2D_FORMAT_S16_10BIT_YUV422;
 			else
 				format = GE2D_FORMAT_S16_12BIT_YUV422;
 		}
 		break;
 	case DECODER_10BIT_BOTTOM:
 		if (vf->type & VIDTYPE_VIU_422) {
 			if (vf->bitdepth & FULL_PACK_422_MODE)
 				format = GE2D_FORMAT_S16_10BIT_YUV422
 					| (GE2D_FORMAT_S16_10BIT_YUV422B
 					& (3 << 3));
 			else
 				format = GE2D_FORMAT_S16_12BIT_YUV422
 					| (GE2D_FORMAT_S16_12BIT_YUV422B
 					& (3 << 3));
 		}
 		break;
 	case DECODER_10BIT_TOP:
 		if (vf->type & VIDTYPE_VIU_422) {
 			if (vf->bitdepth & FULL_PACK_422_MODE)
 				format = GE2D_FORMAT_S16_10BIT_YUV422
 					| (GE2D_FORMAT_S16_10BIT_YUV422T
 					& (3 << 3));
 			else
 				format = GE2D_FORMAT_S16_12BIT_YUV422
 					| (GE2D_FORMAT_S16_12BIT_YUV422T
 					& (3 << 3));
 		}
 		break;
 	default:
 		format = GE2D_FORMAT_M24_YUV420;
 	}
 	return format;
 }

 int vdec_ge2d_init(struct vdec_ge2d** ge2d_handle, int mode)
 {
 	int ret;
 	struct vdec_ge2d *ge2d;

 	if (!ge2d_handle)
 		return -EINVAL;

 	ge2d = kzalloc(sizeof(*ge2d), GFP_KERNEL);
 	if (!ge2d)
 		return -ENOMEM;

 	vdec_canvas_cache_init(ge2d);

 	ge2d->work_mode = mode;
 	if (!ge2d->work_mode) {
 		ge2d->work_mode = GE2D_MODE_CONVERT_LE;
 	}
 	pr_info("vdec_ge2d_init work_mode:%d\n", ge2d->work_mode);

 	ge2d->ge2d_context = create_ge2d_work_queue();
 	if (!ge2d->ge2d_context) {
 		pr_err("ge2d_create_instance fail\n");
 		ret = -EINVAL;
 		goto error;
 	}

 	if (vdec_canvas_cache_get(ge2d, "vdec-ge2d-dec") < 0) {
 		pr_err("canvas pool alloc fail. src(%d, %d, %d) dst(%d, %d, %d).\n",
 			ge2d->canche.res[0].cid,
 			ge2d->canche.res[1].cid,
 			ge2d->canche.res[2].cid,
 			ge2d->canche.res[3].cid,
 			ge2d->canche.res[4].cid,
 			ge2d->canche.res[5].cid);
 		ret = -ENOMEM;
 		goto error1;
 	}

 	*ge2d_handle = ge2d;

 	return 0;
 error1:
 	destroy_ge2d_work_queue(ge2d->ge2d_context);
 error:
 	kfree(ge2d);

 	return ret;
 }
 EXPORT_SYMBOL(vdec_ge2d_init);

 int vdec_ge2d_copy_data(struct vdec_ge2d *ge2d, struct vdec_ge2d_info *ge2d_info)
 {
 	struct config_para_ex_s ge2d_config;
 	u32 src_fmt = 0, dst_fmt = 0;
 	struct canvas_s cd;

 	if (!ge2d)
 		return -1;

 	if (vdec_ge2d_debug)
 		pr_info("vdec_ge2d_copy_data start\n");

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

 	src_fmt = get_input_format(ge2d_info->dst_vf);
 	if (ge2d_info->src_canvas0_config[0].endian == 7)
 		src_fmt |= GE2D_BIG_ENDIAN;
 	else
 		src_fmt |= GE2D_LITTLE_ENDIAN;

 	/* negotiate format of destination */
 	dst_fmt = get_input_format(ge2d_info->dst_vf);
 	if (ge2d->work_mode & GE2D_MODE_CONVERT_NV12)
 		dst_fmt |= GE2D_FORMAT_M24_NV12;
 	else if (ge2d->work_mode & GE2D_MODE_CONVERT_NV21)
 		dst_fmt |= GE2D_FORMAT_M24_NV21;

 	if (ge2d->work_mode & GE2D_MODE_CONVERT_LE)
 		dst_fmt |= GE2D_LITTLE_ENDIAN;
 	else
 		dst_fmt |= GE2D_BIG_ENDIAN;

 	if ((dst_fmt & GE2D_COLOR_MAP_MASK) == GE2D_COLOR_MAP_NV12) {
 		ge2d_info->dst_vf->type |= VIDTYPE_VIU_NV12;
 		ge2d_info->dst_vf->type &= ~VIDTYPE_VIU_NV21;
 	} else if ((dst_fmt & GE2D_COLOR_MAP_MASK) == GE2D_COLOR_MAP_NV21) {
 		ge2d_info->dst_vf->type |= VIDTYPE_VIU_NV21;
 		ge2d_info->dst_vf->type &= ~VIDTYPE_VIU_NV12;
 	}
 	if ((dst_fmt & GE2D_ENDIAN_MASK) == GE2D_LITTLE_ENDIAN) {
 		ge2d_info->dst_vf->canvas0_config[0].endian = 0;
 		ge2d_info->dst_vf->canvas0_config[1].endian = 0;
 		ge2d_info->dst_vf->canvas0_config[2].endian = 0;
 	} else if ((dst_fmt & GE2D_ENDIAN_MASK) == GE2D_BIG_ENDIAN){
 		ge2d_info->dst_vf->canvas0_config[0].endian = 7;
 		ge2d_info->dst_vf->canvas0_config[1].endian = 7;
 		ge2d_info->dst_vf->canvas0_config[2].endian = 7;
 	}

 	ge2d_info->dst_vf->mem_sec = ge2d_info->dst_vf->flag & VFRAME_FLAG_VIDEO_SECURE ? 1 : 0;

 	mutex_lock(&ge2d->canche.lock);

 	/* src canvas configure. */
 	if ((ge2d_info->dst_vf->canvas0Addr == 0) ||
 		(ge2d_info->dst_vf->canvas0Addr == (u32)-1)) {
 		canvas_config_config(ge2d->canche.res[0].cid, &ge2d_info->src_canvas0_config[0]);
 		canvas_config_config(ge2d->canche.res[1].cid, &ge2d_info->src_canvas0_config[1]);
 		canvas_config_config(ge2d->canche.res[2].cid, &ge2d_info->src_canvas0_config[2]);
 		ge2d_config.src_para.canvas_index =
 			ge2d->canche.res[0].cid |
 			ge2d->canche.res[1].cid << 8 |
 			ge2d->canche.res[2].cid << 16;

 		ge2d_config.src_planes[0].addr =
 			ge2d_info->src_canvas0_config[0].phy_addr;
 		ge2d_config.src_planes[0].w =
 			ge2d_info->src_canvas0_config[0].width;
 		ge2d_config.src_planes[0].h =
 			ge2d_info->src_canvas0_config[0].height;
 		ge2d_config.src_planes[1].addr =
 			ge2d_info->src_canvas0_config[1].phy_addr;
 		ge2d_config.src_planes[1].w =
 			ge2d_info->src_canvas0_config[1].width;
 		ge2d_config.src_planes[1].h =
 			ge2d_info->src_canvas0_config[1].height;
 		ge2d_config.src_planes[2].addr =
 			ge2d_info->src_canvas0_config[2].phy_addr;
 		ge2d_config.src_planes[2].w =
 			ge2d_info->src_canvas0_config[2].width;
 		ge2d_config.src_planes[2].h =
 			ge2d_info->src_canvas0_config[2].height;
 	} else {
 		ge2d_config.src_para.canvas_index = ge2d_info->src_canvas0Addr;
 	}
 	ge2d_config.src_para.mem_type	= CANVAS_TYPE_INVALID;
 	ge2d_config.src_para.format = src_fmt;
 	ge2d_config.src_para.fill_color_en = 0;
 	ge2d_config.src_para.fill_mode	= 0;
 	ge2d_config.src_para.x_rev	= 0;
 	ge2d_config.src_para.y_rev	= 0;
 	ge2d_config.src_para.color	= 0xffffffff;
 	ge2d_config.src_para.top	= 0;
 	ge2d_config.src_para.left	= 0;
 	ge2d_config.src_para.width	= ge2d_info->dst_vf->width;
 	if (ge2d_info->dst_vf->type & VIDTYPE_INTERLACE)
 		ge2d_config.src_para.height = ge2d_info->dst_vf->height >> 1;
 	else
 		ge2d_config.src_para.height = ge2d_info->dst_vf->height;

 	/* dst canvas configure. */
 	canvas_config_config(ge2d->canche.res[3].cid, &ge2d_info->dst_vf->canvas0_config[0]);
 	if ((ge2d_config.src_para.format & 0xfffff) == GE2D_FORMAT_M24_YUV420) {
 		ge2d_info->dst_vf->canvas0_config[1].width <<= 1;
 	}
 	canvas_config_config(ge2d->canche.res[4].cid, &ge2d_info->dst_vf->canvas0_config[1]);
 	canvas_config_config(ge2d->canche.res[5].cid, &ge2d_info->dst_vf->canvas0_config[2]);
 	ge2d_config.dst_para.canvas_index =
 		ge2d->canche.res[3].cid |
 		ge2d->canche.res[4].cid << 8;
 	canvas_read(ge2d->canche.res[3].cid, &cd);
 	ge2d_config.dst_planes[0].addr	= cd.addr;
 	ge2d_config.dst_planes[0].w	= cd.width;
 	ge2d_config.dst_planes[0].h	= cd.height;
 	canvas_read(ge2d->canche.res[4].cid, &cd);
 	ge2d_config.dst_planes[1].addr	= cd.addr;
 	ge2d_config.dst_planes[1].w	= cd.width;
 	ge2d_config.dst_planes[1].h	= cd.height;

 	ge2d_config.dst_para.format	=  dst_fmt;
 	ge2d_config.dst_para.width	= ge2d_info->dst_vf->width;
 	ge2d_config.dst_para.height	= ge2d_info->dst_vf->height;
 	ge2d_config.dst_para.mem_type	= CANVAS_TYPE_INVALID;
 	ge2d_config.dst_para.fill_color_en = 0;
 	ge2d_config.dst_para.fill_mode	= 0;
 	ge2d_config.dst_para.x_rev	= 0;
 	ge2d_config.dst_para.y_rev	= 0;
 	ge2d_config.dst_para.color	= 0;
 	ge2d_config.dst_para.top	= 0;
 	ge2d_config.dst_para.left	= 0;

 	/* other ge2d parameters configure. */
 	ge2d_config.src_key.key_enable	= 0;
 	ge2d_config.src_key.key_mask	= 0;
 	ge2d_config.src_key.key_mode	= 0;
 	ge2d_config.alu_const_color	= 0;
 	ge2d_config.bitmask_en		= 0;
 	ge2d_config.src1_gb_alpha	= 0;
 	ge2d_config.dst_xy_swap		= 0;
 	ge2d_config.src2_para.mem_type	= CANVAS_TYPE_INVALID;
 	ge2d_config.mem_sec	= ge2d_info->dst_vf->flag & VFRAME_FLAG_VIDEO_SECURE ? 1 : 0;

 	if (ge2d_context_config_ex(ge2d->ge2d_context, &ge2d_config) < 0) {
 		pr_err("vdec_ge2d_context_config_ex error.\n");
 		mutex_unlock(&ge2d->canche.lock);
 		return -1;
 	}

 	if (!(ge2d_info->dst_vf->type & VIDTYPE_V4L_EOS)) {
 		if (ge2d_info->dst_vf->type & VIDTYPE_INTERLACE) {
 			stretchblt_noalpha(ge2d->ge2d_context,
 				0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height / 2,
 				0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height);
 		} else {
 			stretchblt_noalpha(ge2d->ge2d_context,
 				0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height,
 				0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height);
 		}
 	}
 	mutex_unlock(&ge2d->canche.lock);
 	if (vdec_ge2d_debug)
 		pr_info("vdec_ge2d_copy_data done\n");

 	return 0;
 }
 EXPORT_SYMBOL(vdec_ge2d_copy_data);

 int vdec_ge2d_destroy(struct vdec_ge2d *ge2d)
 {
 	if (!ge2d)
 		return -1;

 	pr_info("vdec ge2d destroy begin\n");

 	destroy_ge2d_work_queue(ge2d->ge2d_context);
 	vdec_canvas_cache_put(ge2d);
 	kfree(ge2d);

 	pr_info("vdec ge2d destroy done\n");

 	return 0;
 }
 EXPORT_SYMBOL(vdec_ge2d_destroy);

 module_param(vdec_ge2d_debug, int, 0664);
 MODULE_PARM_DESC(vdec_ge2d_debug, "\n vdec_ge2d_debug\n");
	/*
	* Copyright (C) 2017 Amlogic, Inc. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	* more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,
	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	*
	* Description:
	*/
	#include <linux/types.h>
	#include <linux/slab.h>
	#include <linux/module.h>
	#include <linux/amlogic/media/ge2d/ge2d.h>
	#include <linux/amlogic/media/canvas/canvas_mgr.h>
	#include "vdec.h"
	#include "vdec_ge2d_utils.h"
	#include "../../../common/chips/decoder_cpu_ver_info.h"

	static u32 vdec_ge2d_debug = 0;

	#ifndef CONFIG_AMLOGIC_MEDIA_GE2D
	inline struct ge2d_context_s *create_ge2d_work_queue(void) { return NULL; }
	inline int destroy_ge2d_work_queue(struct ge2d_context_s *ge2d_work_queue) { return -1; }
	#endif

	enum videocom_source_type {
	DECODER_8BIT_NORMAL = 0,
	DECODER_8BIT_BOTTOM,
	DECODER_8BIT_TOP,
	DECODER_10BIT_NORMAL,
	DECODER_10BIT_BOTTOM,
	DECODER_10BIT_TOP
	};

	static void vdec_canvas_cache_free(struct vdec_canvas_cache *canche)
	{
	int i = -1;

	for (i = 0; i < ARRAY_SIZE(canche->res); i++) {
	if (canche->res[i].cid > 0) {
	if (vdec_ge2d_debug)
	pr_info("canvas-free, name:%s, canvas id:%d\n",
	canche->res[i].name,
	canche->res[i].cid);

	canvas_pool_map_free_canvas(canche->res[i].cid);

	canche->res[i].cid = 0;
	}
	}
	}

	static void vdec_canvas_cache_put(struct vdec_ge2d *ge2d)
	{
	struct vdec_canvas_cache *canche = &ge2d->canche;

	mutex_lock(&canche->lock);

	pr_info("canvas-put, ref:%d\n", canche->ref);

	canche->ref--;

	if (canche->ref == 0) {
	vdec_canvas_cache_free(canche);
	}

	mutex_unlock(&canche->lock);
	}

	static int vdec_canvas_cache_get(struct vdec_ge2d ge2d, char usr)
	{
	struct vdec_canvas_cache *canche = &ge2d->canche;
	int i;

	mutex_lock(&canche->lock);

	canche->ref++;

	for (i = 0; i < ARRAY_SIZE(canche->res); i++) {
	if (canche->res[i].cid <= 0) {
	snprintf(canche->res[i].name, 32, "%s-%d", usr, i);
	canche->res[i].cid =
	canvas_pool_map_alloc_canvas(canche->res[i].name);
	}

	if (vdec_ge2d_debug)
	pr_info("canvas-alloc, name:%s, canvas id:%d\n",
	canche->res[i].name,
	canche->res[i].cid);

	if (canche->res[i].cid <= 0) {
	pr_err("canvas-fail, name:%s, canvas id:%d.\n",
	canche->res[i].name,
	canche->res[i].cid);

	mutex_unlock(&canche->lock);
	goto err;
	}
	}

	if (vdec_ge2d_debug)
	pr_info("canvas-get, ref:%d\n", canche->ref);

	mutex_unlock(&canche->lock);
	return 0;
	err:
	vdec_canvas_cache_put(ge2d);
	return -1;
	}

	static int vdec_canvas_cache_init(struct vdec_ge2d *ge2d)
	{
	ge2d->canche.ref = 0;
	mutex_init(&ge2d->canche.lock);

	pr_info("canvas-init, ref:%d\n", ge2d->canche.ref);

	return 0;
	}

	static int get_source_type(struct vframe_s *vf)
	{
	enum videocom_source_type ret;
	int interlace_mode;

	interlace_mode = vf->type & VIDTYPE_TYPEMASK;

	if ((vf->bitdepth & BITDEPTH_Y10) &&
	(!(vf->type & VIDTYPE_COMPRESS)) &&
	(get_cpu_type() >= MESON_CPU_MAJOR_ID_TXL)) {
	if (interlace_mode == VIDTYPE_INTERLACE_TOP)
	ret = DECODER_10BIT_TOP;
	else if (interlace_mode == VIDTYPE_INTERLACE_BOTTOM)
	ret = DECODER_10BIT_BOTTOM;
	else
	ret = DECODER_10BIT_NORMAL;
	} else {
	if (interlace_mode == VIDTYPE_INTERLACE_TOP)
	ret = DECODER_8BIT_TOP;
	else if (interlace_mode == VIDTYPE_INTERLACE_BOTTOM)
	ret = DECODER_8BIT_BOTTOM;
	else
	ret = DECODER_8BIT_NORMAL;
	}

	return ret;
	}

	static int get_input_format(struct vframe_s *vf)
	{
	int format = GE2D_FORMAT_M24_YUV420;
	enum videocom_source_type soure_type;

	soure_type = get_source_type(vf);

	switch (soure_type) {
	case DECODER_8BIT_NORMAL:
	if (vf->type & VIDTYPE_VIU_422)
	format = GE2D_FORMAT_S16_YUV422;
	else if (vf->type & VIDTYPE_VIU_NV21)
	format = GE2D_FORMAT_M24_NV21;
	else if (vf->type & VIDTYPE_VIU_NV12)
	format = GE2D_FORMAT_M24_NV12;
	else if (vf->type & VIDTYPE_VIU_444)
	format = GE2D_FORMAT_S24_YUV444;
	else
	format = GE2D_FORMAT_M24_YUV420;
	break;
	case DECODER_8BIT_BOTTOM:
	if (vf->type & VIDTYPE_VIU_422)
	format = GE2D_FORMAT_S16_YUV422
	\| (GE2D_FORMAT_S16_YUV422B & (3 << 3));
	else if (vf->type & VIDTYPE_VIU_NV21)
	format = GE2D_FORMAT_M24_NV21
	\| (GE2D_FORMAT_M24_NV21B & (3 << 3));
	else if (vf->type & VIDTYPE_VIU_NV12)
	format = GE2D_FORMAT_M24_NV12
	\| (GE2D_FORMAT_M24_NV12B & (3 << 3));
	else if (vf->type & VIDTYPE_VIU_444)
	format = GE2D_FORMAT_S24_YUV444
	\| (GE2D_FORMAT_S24_YUV444B & (3 << 3));
	else
	format = GE2D_FORMAT_M24_YUV420
	\| (GE2D_FMT_M24_YUV420B & (3 << 3));
	break;
	case DECODER_8BIT_TOP:
	if (vf->type & VIDTYPE_VIU_422)
	format = GE2D_FORMAT_S16_YUV422
	\| (GE2D_FORMAT_S16_YUV422T & (3 << 3));
	else if (vf->type & VIDTYPE_VIU_NV21)
	format = GE2D_FORMAT_M24_NV21
	\| (GE2D_FORMAT_M24_NV21T & (3 << 3));
	else if (vf->type & VIDTYPE_VIU_NV12)
	format = GE2D_FORMAT_M24_NV12
	\| (GE2D_FORMAT_M24_NV12T & (3 << 3));
	else if (vf->type & VIDTYPE_VIU_444)
	format = GE2D_FORMAT_S24_YUV444
	\| (GE2D_FORMAT_S24_YUV444T & (3 << 3));
	else
	format = GE2D_FORMAT_M24_YUV420
	\| (GE2D_FMT_M24_YUV420T & (3 << 3));
	break;
	case DECODER_10BIT_NORMAL:
	if (vf->type & VIDTYPE_VIU_422) {
	if (vf->bitdepth & FULL_PACK_422_MODE)
	format = GE2D_FORMAT_S16_10BIT_YUV422;
	else
	format = GE2D_FORMAT_S16_12BIT_YUV422;
	}
	break;
	case DECODER_10BIT_BOTTOM:
	if (vf->type & VIDTYPE_VIU_422) {
	if (vf->bitdepth & FULL_PACK_422_MODE)
	format = GE2D_FORMAT_S16_10BIT_YUV422
	\| (GE2D_FORMAT_S16_10BIT_YUV422B
	& (3 << 3));
	else
	format = GE2D_FORMAT_S16_12BIT_YUV422
	\| (GE2D_FORMAT_S16_12BIT_YUV422B
	& (3 << 3));
	}
	break;
	case DECODER_10BIT_TOP:
	if (vf->type & VIDTYPE_VIU_422) {
	if (vf->bitdepth & FULL_PACK_422_MODE)
	format = GE2D_FORMAT_S16_10BIT_YUV422
	\| (GE2D_FORMAT_S16_10BIT_YUV422T
	& (3 << 3));
	else
	format = GE2D_FORMAT_S16_12BIT_YUV422
	\| (GE2D_FORMAT_S16_12BIT_YUV422T
	& (3 << 3));
	}
	break;
	default:
	format = GE2D_FORMAT_M24_YUV420;
	}
	return format;
	}

	int vdec_ge2d_init(struct vdec_ge2d** ge2d_handle, int mode)
	{
	int ret;
	struct vdec_ge2d *ge2d;

	if (!ge2d_handle)
	return -EINVAL;

	ge2d = kzalloc(sizeof(*ge2d), GFP_KERNEL);
	if (!ge2d)
	return -ENOMEM;

	vdec_canvas_cache_init(ge2d);

	ge2d->work_mode = mode;
	if (!ge2d->work_mode) {
	ge2d->work_mode = GE2D_MODE_CONVERT_LE;
	}
	pr_info("vdec_ge2d_init work_mode:%d\n", ge2d->work_mode);

	ge2d->ge2d_context = create_ge2d_work_queue();
	if (!ge2d->ge2d_context) {
	pr_err("ge2d_create_instance fail\n");
	ret = -EINVAL;
	goto error;
	}

	if (vdec_canvas_cache_get(ge2d, "vdec-ge2d-dec") < 0) {
	pr_err("canvas pool alloc fail. src(%d, %d, %d) dst(%d, %d, %d).\n",
	ge2d->canche.res[0].cid,
	ge2d->canche.res[1].cid,
	ge2d->canche.res[2].cid,
	ge2d->canche.res[3].cid,
	ge2d->canche.res[4].cid,
	ge2d->canche.res[5].cid);
	ret = -ENOMEM;
	goto error1;
	}

	*ge2d_handle = ge2d;

	return 0;
	error1:
	destroy_ge2d_work_queue(ge2d->ge2d_context);
	error:
	kfree(ge2d);

	return ret;
	}
	EXPORT_SYMBOL(vdec_ge2d_init);

	int vdec_ge2d_copy_data(struct vdec_ge2d ge2d, struct vdec_ge2d_info ge2d_info)
	{
	struct config_para_ex_s ge2d_config;
	u32 src_fmt = 0, dst_fmt = 0;
	struct canvas_s cd;

	if (!ge2d)
	return -1;

	if (vdec_ge2d_debug)
	pr_info("vdec_ge2d_copy_data start\n");

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

	src_fmt = get_input_format(ge2d_info->dst_vf);
	if (ge2d_info->src_canvas0_config[0].endian == 7)
	src_fmt \|= GE2D_BIG_ENDIAN;
	else
	src_fmt \|= GE2D_LITTLE_ENDIAN;

	/* negotiate format of destination */
	dst_fmt = get_input_format(ge2d_info->dst_vf);
	if (ge2d->work_mode & GE2D_MODE_CONVERT_NV12)
	dst_fmt \|= GE2D_FORMAT_M24_NV12;
	else if (ge2d->work_mode & GE2D_MODE_CONVERT_NV21)
	dst_fmt \|= GE2D_FORMAT_M24_NV21;

	if (ge2d->work_mode & GE2D_MODE_CONVERT_LE)
	dst_fmt \|= GE2D_LITTLE_ENDIAN;
	else
	dst_fmt \|= GE2D_BIG_ENDIAN;

	if ((dst_fmt & GE2D_COLOR_MAP_MASK) == GE2D_COLOR_MAP_NV12) {
	ge2d_info->dst_vf->type \|= VIDTYPE_VIU_NV12;
	ge2d_info->dst_vf->type &= ~VIDTYPE_VIU_NV21;
	} else if ((dst_fmt & GE2D_COLOR_MAP_MASK) == GE2D_COLOR_MAP_NV21) {
	ge2d_info->dst_vf->type \|= VIDTYPE_VIU_NV21;
	ge2d_info->dst_vf->type &= ~VIDTYPE_VIU_NV12;
	}
	if ((dst_fmt & GE2D_ENDIAN_MASK) == GE2D_LITTLE_ENDIAN) {
	ge2d_info->dst_vf->canvas0_config[0].endian = 0;
	ge2d_info->dst_vf->canvas0_config[1].endian = 0;
	ge2d_info->dst_vf->canvas0_config[2].endian = 0;
	} else if ((dst_fmt & GE2D_ENDIAN_MASK) == GE2D_BIG_ENDIAN){
	ge2d_info->dst_vf->canvas0_config[0].endian = 7;
	ge2d_info->dst_vf->canvas0_config[1].endian = 7;
	ge2d_info->dst_vf->canvas0_config[2].endian = 7;
	}

	ge2d_info->dst_vf->mem_sec = ge2d_info->dst_vf->flag & VFRAME_FLAG_VIDEO_SECURE ? 1 : 0;

	mutex_lock(&ge2d->canche.lock);

	/* src canvas configure. */
	if ((ge2d_info->dst_vf->canvas0Addr == 0) \|\|
	(ge2d_info->dst_vf->canvas0Addr == (u32)-1)) {
	canvas_config_config(ge2d->canche.res[0].cid, &ge2d_info->src_canvas0_config[0]);
	canvas_config_config(ge2d->canche.res[1].cid, &ge2d_info->src_canvas0_config[1]);
	canvas_config_config(ge2d->canche.res[2].cid, &ge2d_info->src_canvas0_config[2]);
	ge2d_config.src_para.canvas_index =
	ge2d->canche.res[0].cid \|
	ge2d->canche.res[1].cid << 8 \|
	ge2d->canche.res[2].cid << 16;

	ge2d_config.src_planes[0].addr =
	ge2d_info->src_canvas0_config[0].phy_addr;
	ge2d_config.src_planes[0].w =
	ge2d_info->src_canvas0_config[0].width;
	ge2d_config.src_planes[0].h =
	ge2d_info->src_canvas0_config[0].height;
	ge2d_config.src_planes[1].addr =
	ge2d_info->src_canvas0_config[1].phy_addr;
	ge2d_config.src_planes[1].w =
	ge2d_info->src_canvas0_config[1].width;
	ge2d_config.src_planes[1].h =
	ge2d_info->src_canvas0_config[1].height;
	ge2d_config.src_planes[2].addr =
	ge2d_info->src_canvas0_config[2].phy_addr;
	ge2d_config.src_planes[2].w =
	ge2d_info->src_canvas0_config[2].width;
	ge2d_config.src_planes[2].h =
	ge2d_info->src_canvas0_config[2].height;
	} else {
	ge2d_config.src_para.canvas_index = ge2d_info->src_canvas0Addr;
	}
	ge2d_config.src_para.mem_type = CANVAS_TYPE_INVALID;
	ge2d_config.src_para.format = src_fmt;
	ge2d_config.src_para.fill_color_en = 0;
	ge2d_config.src_para.fill_mode = 0;
	ge2d_config.src_para.x_rev = 0;
	ge2d_config.src_para.y_rev = 0;
	ge2d_config.src_para.color = 0xffffffff;
	ge2d_config.src_para.top = 0;
	ge2d_config.src_para.left = 0;
	ge2d_config.src_para.width = ge2d_info->dst_vf->width;
	if (ge2d_info->dst_vf->type & VIDTYPE_INTERLACE)
	ge2d_config.src_para.height = ge2d_info->dst_vf->height >> 1;
	else
	ge2d_config.src_para.height = ge2d_info->dst_vf->height;

	/* dst canvas configure. */
	canvas_config_config(ge2d->canche.res[3].cid, &ge2d_info->dst_vf->canvas0_config[0]);
	if ((ge2d_config.src_para.format & 0xfffff) == GE2D_FORMAT_M24_YUV420) {
	ge2d_info->dst_vf->canvas0_config[1].width <<= 1;
	}
	canvas_config_config(ge2d->canche.res[4].cid, &ge2d_info->dst_vf->canvas0_config[1]);
	canvas_config_config(ge2d->canche.res[5].cid, &ge2d_info->dst_vf->canvas0_config[2]);
	ge2d_config.dst_para.canvas_index =
	ge2d->canche.res[3].cid \|
	ge2d->canche.res[4].cid << 8;
	canvas_read(ge2d->canche.res[3].cid, &cd);
	ge2d_config.dst_planes[0].addr = cd.addr;
	ge2d_config.dst_planes[0].w = cd.width;
	ge2d_config.dst_planes[0].h = cd.height;
	canvas_read(ge2d->canche.res[4].cid, &cd);
	ge2d_config.dst_planes[1].addr = cd.addr;
	ge2d_config.dst_planes[1].w = cd.width;
	ge2d_config.dst_planes[1].h = cd.height;

	ge2d_config.dst_para.format = dst_fmt;
	ge2d_config.dst_para.width = ge2d_info->dst_vf->width;
	ge2d_config.dst_para.height = ge2d_info->dst_vf->height;
	ge2d_config.dst_para.mem_type = CANVAS_TYPE_INVALID;
	ge2d_config.dst_para.fill_color_en = 0;
	ge2d_config.dst_para.fill_mode = 0;
	ge2d_config.dst_para.x_rev = 0;
	ge2d_config.dst_para.y_rev = 0;
	ge2d_config.dst_para.color = 0;
	ge2d_config.dst_para.top = 0;
	ge2d_config.dst_para.left = 0;

	/* other ge2d parameters configure. */
	ge2d_config.src_key.key_enable = 0;
	ge2d_config.src_key.key_mask = 0;
	ge2d_config.src_key.key_mode = 0;
	ge2d_config.alu_const_color = 0;
	ge2d_config.bitmask_en = 0;
	ge2d_config.src1_gb_alpha = 0;
	ge2d_config.dst_xy_swap = 0;
	ge2d_config.src2_para.mem_type = CANVAS_TYPE_INVALID;
	ge2d_config.mem_sec = ge2d_info->dst_vf->flag & VFRAME_FLAG_VIDEO_SECURE ? 1 : 0;

	if (ge2d_context_config_ex(ge2d->ge2d_context, &ge2d_config) < 0) {
	pr_err("vdec_ge2d_context_config_ex error.\n");
	mutex_unlock(&ge2d->canche.lock);
	return -1;
	}

	if (!(ge2d_info->dst_vf->type & VIDTYPE_V4L_EOS)) {
	if (ge2d_info->dst_vf->type & VIDTYPE_INTERLACE) {
	stretchblt_noalpha(ge2d->ge2d_context,
	0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height / 2,
	0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height);
	} else {
	stretchblt_noalpha(ge2d->ge2d_context,
	0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height,
	0, 0, ge2d_info->dst_vf->width, ge2d_info->dst_vf->height);
	}
	}
	mutex_unlock(&ge2d->canche.lock);
	if (vdec_ge2d_debug)
	pr_info("vdec_ge2d_copy_data done\n");

	return 0;
	}
	EXPORT_SYMBOL(vdec_ge2d_copy_data);

	int vdec_ge2d_destroy(struct vdec_ge2d *ge2d)
	{
	if (!ge2d)
	return -1;

	pr_info("vdec ge2d destroy begin\n");

	destroy_ge2d_work_queue(ge2d->ge2d_context);
	vdec_canvas_cache_put(ge2d);
	kfree(ge2d);

	pr_info("vdec ge2d destroy done\n");

	return 0;
	}
	EXPORT_SYMBOL(vdec_ge2d_destroy);

	module_param(vdec_ge2d_debug, int, 0664);
	MODULE_PARM_DESC(vdec_ge2d_debug, "\n vdec_ge2d_debug\n");