X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=drivers%2Fvideo%2Frockchip%2Frk_fb.c;h=8f3afff60d239943cca9d9630c6df1268c935fbf;hb=05b29f94a4ab4f37071025b0c235516c2616bce6;hp=07daf387e1c9a47282f06e11e7fc84b19a57e13c;hpb=686c2212a69cadabe0bff2cd0f1a65ab7143b845;p=firefly-linux-kernel-4.4.55.git

diff --git a/drivers/video/rockchip/rk_fb.c b/drivers/video/rockchip/rk_fb.c
old mode 100644
new mode 100755
index 07daf387e1c9..8f3afff60d23
--- a/drivers/video/rockchip/rk_fb.c
+++ b/drivers/video/rockchip/rk_fb.c
@@ -35,7 +35,7 @@
 #include "bmp_helper.h"
 
 #if defined(CONFIG_RK_HDMI)
-#include "hdmi/rk_hdmi.h"
+#include "hdmi/rockchip-hdmi.h"
 #endif
 
 #if defined(CONFIG_ROCKCHIP_RGA) || defined(CONFIG_ROCKCHIP_RGA2)
@@ -59,9 +59,10 @@
 #endif
 
 #define H_USE_FENCE 1
+/* #define FB_ROATE_BY_KERNEL 1 */
+
 static int hdmi_switch_complete;
 static struct platform_device *fb_pdev;
-struct list_head saved_list;
 
 #if defined(CONFIG_FB_MIRRORING)
 int (*video_data_to_mirroring) (struct fb_info *info, u32 yuv_phy[2]);
@@ -98,6 +99,8 @@ int rk_fb_trsm_ops_register(struct rk_fb_trsm_ops *ops, int type)
 	case SCREEN_RGB:
 	case SCREEN_LVDS:
 	case SCREEN_DUAL_LVDS:
+	case SCREEN_LVDS_10BIT:
+	case SCREEN_DUAL_LVDS_10BIT:
 		trsm_lvds_ops = ops;
 		break;
 	case SCREEN_EDP:
@@ -122,6 +125,8 @@ struct rk_fb_trsm_ops *rk_fb_trsm_ops_get(int type)
 	case SCREEN_RGB:
 	case SCREEN_LVDS:
 	case SCREEN_DUAL_LVDS:
+	case SCREEN_LVDS_10BIT:
+	case SCREEN_DUAL_LVDS_10BIT:
 		ops = trsm_lvds_ops;
 		break;
 	case SCREEN_EDP:
@@ -147,16 +152,21 @@ int rk_fb_pixel_width(int data_format)
 	case XBGR888:
 	case ABGR888:
 	case ARGB888:
+	case FBDC_ARGB_888:
+	case FBDC_ABGR_888:
+	case FBDC_RGBX_888:
 		pixel_width = 4 * 8;
 		break;
 	case RGB888:
 		pixel_width = 3 * 8;
 		break;
 	case RGB565:
+	case FBDC_RGB_565:
 		pixel_width = 2 * 8;
 		break;
 	case YUV422:
 	case YUV420:
+	case YUV420_NV21:
 	case YUV444:
 		pixel_width = 1 * 8;
 		break;
@@ -196,6 +206,9 @@ static int rk_fb_data_fmt(int data_format, int bits_per_pixel)
 		case HAL_PIXEL_FORMAT_YCbCr_422_SP:	/* yuv422 */
 			fb_data_fmt = YUV422;
 			break;
+		case HAL_PIXEL_FORMAT_YCrCb_420_SP:	/* YUV420---vuvuvu */
+			fb_data_fmt = YUV420_NV21;
+			break;
 		case HAL_PIXEL_FORMAT_YCrCb_NV12:	/* YUV420---uvuvuv */
 			fb_data_fmt = YUV420;
 			break;
@@ -211,6 +224,18 @@ static int rk_fb_data_fmt(int data_format, int bits_per_pixel)
 		case HAL_PIXEL_FORMAT_YCrCb_420_SP_10:	/* yuv444 */
 			fb_data_fmt = YUV444_A;
 			break;
+		case HAL_PIXEL_FORMAT_FBDC_RGB565:	/* fbdc rgb565*/
+			fb_data_fmt = FBDC_RGB_565;
+			break;
+		case HAL_PIXEL_FORMAT_FBDC_U8U8U8U8:	/* fbdc argb888 */
+			fb_data_fmt = FBDC_ARGB_888;
+			break;
+		case HAL_PIXEL_FORMAT_FBDC_RGBA888:	/* fbdc abgr888 */
+			fb_data_fmt = FBDC_ABGR_888;
+			break;
+		case HAL_PIXEL_FORMAT_FBDC_U8U8U8:	/* fbdc rgb888 */
+			fb_data_fmt = FBDC_RGBX_888;
+			break;
 		default:
 			printk(KERN_WARNING "%s:un supported format:0x%x\n",
 			       __func__, data_format);
@@ -426,6 +451,7 @@ int rk_fb_video_mode_from_timing(const struct display_timing *dt,
 	screen->face = dt->face;
 	screen->color_mode = dt->color_mode;
 	screen->dsp_lut = dt->dsp_lut;
+	screen->cabc_lut = dt->cabc_lut;
 
 	if (dt->flags & DISPLAY_FLAGS_PIXDATA_POSEDGE)
 		screen->pin_dclk = 1;
@@ -502,6 +528,7 @@ char *get_format_string(enum data_format format, char *fmt)
 		strcpy(fmt, "RGB565");
 		break;
 	case YUV420:
+	case YUV420_NV21:
 		strcpy(fmt, "YUV420");
 		break;
 	case YUV422:
@@ -528,6 +555,16 @@ char *get_format_string(enum data_format format, char *fmt)
 	case ABGR888:
 		strcpy(fmt, "ABGR888");
 		break;
+	case FBDC_RGB_565:
+		strcpy(fmt, "FBDC_RGB_565");
+		break;
+	case FBDC_ARGB_888:
+	case FBDC_ABGR_888:
+		strcpy(fmt, "FBDC_ARGB_888");
+		break;
+	case FBDC_RGBX_888:
+		strcpy(fmt, "FBDC_RGBX_888");
+		break;
 	default:
 		strcpy(fmt, "invalid");
 		break;
@@ -583,6 +620,27 @@ static struct rk_lcdc_driver *rk_get_prmry_lcdc_drv(void)
 	return dev_drv;
 }
 
+static __maybe_unused struct rk_lcdc_driver *rk_get_extend_lcdc_drv(void)
+{
+	struct rk_fb *inf = NULL;
+	struct rk_lcdc_driver *dev_drv = NULL;
+	int i = 0;
+
+	if (likely(fb_pdev))
+		inf = platform_get_drvdata(fb_pdev);
+	else
+		return NULL;
+
+	for (i = 0; i < inf->num_lcdc; i++) {
+		if (inf->lcdc_dev_drv[i]->prop == EXTEND) {
+			dev_drv = inf->lcdc_dev_drv[i];
+			break;
+		}
+	}
+
+	return dev_drv;
+}
+
 /*
  * get one frame time of the prmry screen, unit: us
  */
@@ -694,27 +752,6 @@ int rk_fb_set_prmry_screen_status(int status)
 	return 0;
 }
 
-static struct rk_lcdc_driver *rk_get_extend_lcdc_drv(void)
-{
-	struct rk_fb *inf = NULL;
-	struct rk_lcdc_driver *dev_drv = NULL;
-	int i = 0;
-
-	if (likely(fb_pdev))
-		inf = platform_get_drvdata(fb_pdev);
-	else
-		return NULL;
-
-	for (i = 0; i < inf->num_lcdc; i++) {
-		if (inf->lcdc_dev_drv[i]->prop == EXTEND) {
-			dev_drv = inf->lcdc_dev_drv[i];
-			break;
-		}
-	}
-
-	return dev_drv;
-}
-
 u32 rk_fb_get_prmry_screen_pixclock(void)
 {
 	struct rk_lcdc_driver *dev_drv = rk_get_prmry_lcdc_drv();
@@ -824,26 +861,6 @@ static int rk_fb_open(struct fb_info *info, int user)
 	return 0;
 }
 
-static int get_extend_fb_id(struct fb_info *info)
-{
-	int fb_id = 0;
-	char *id = info->fix.id;
-	struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
-	struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
-
-	if (!strcmp(id, "fb0"))
-		fb_id = 0;
-	else if (!strcmp(id, "fb1"))
-		fb_id = 1;
-	else if (!strcmp(id, "fb2") && (dev_drv->lcdc_win_num > 2))
-		fb_id = 2;
-	else if (!strcmp(id, "fb3") && (dev_drv->lcdc_win_num > 3))
-		fb_id = 3;
-	else if (!strcmp(id, "fb4") && (dev_drv->lcdc_win_num > 4))
-		fb_id = 4;
-	return fb_id;
-}
-
 static int rk_fb_close(struct fb_info *info, int user)
 {
 	struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
@@ -887,6 +904,7 @@ static int rk_fb_close(struct fb_info *info, int user)
 	return 0;
 }
 
+#if defined(FB_ROATE_BY_KERNEL)
 
 #if defined(CONFIG_RK29_IPP)
 static int get_ipp_format(int fmt)
@@ -1203,7 +1221,6 @@ static void fb_copy_by_rga(struct fb_info *dst_info,
 	win_copy_by_rga(dst_win, src_win, ext_dev_drv->rotate_mode,
 			ext_dev_drv->iommu_enabled);
 }
-
 #endif
 
 static int rk_fb_rotate(struct fb_info *dst_info,
@@ -1232,137 +1249,20 @@ static int __maybe_unused rk_fb_win_rotate(struct rk_lcdc_win *dst_win,
 	return 0;
 }
 
-static int rk_fb_set_ext_win_buffer(struct rk_lcdc_win *ext_win,
-					 struct rk_lcdc_win *win,
-					 u16 rotate, int iommu_en)
-{
-	struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
-	struct fb_info *ext_info = rk_fb->fb[(rk_fb->num_fb >> 1)];
-	struct rk_fb_par *ext_fb_par = (struct rk_fb_par *)ext_info->par;
-	struct rk_lcdc_driver *ext_dev_drv = rk_get_extend_lcdc_drv();
-	struct rk_lcdc_win *last_win;
-	static u8 fb_index = 0;
-	ion_phys_addr_t phy_addr;
-	size_t len = 0;
-	int ret = 0;
-	bool is_yuv = false;
-
-	if (unlikely(!ext_win) || unlikely(!win))
-		return -1;
-
-	if (rk_fb->disp_mode != DUAL || ext_info == NULL)
-		return 0;
-
-	switch (ext_win->area[0].format) {
-        case YUV422:
-        case YUV420:
-        case YUV444:
-        case YUV422_A:
-        case YUV420_A:
-        case YUV444_A:
-                is_yuv = true;
-                break;
-        default:
-                is_yuv = false;
-                break;
-        }
-
-	/* no rotate mode */
-	if (rotate <= X_Y_MIRROR) {
-		if (iommu_en) {
-			ret = ion_map_iommu(ext_dev_drv->dev,
-					    rk_fb->ion_client,
-					    win->area[0].ion_hdl,
-					    (unsigned long *)&phy_addr,
-					    (unsigned long *)&len);
-			if (ret < 0) {
-				dev_err(ext_dev_drv->dev, "ion map to get phy addr failed\n");
-				ion_free(rk_fb->ion_client, win->area[0].ion_hdl);
-				return -ENOMEM;
-			}
-			ext_win->area[0].smem_start = phy_addr;
-			ext_win->area[0].y_offset = win->area[0].y_offset;
-			if (is_yuv) {
-				ext_win->area[0].cbr_start = win->area[0].cbr_start;
-				ext_win->area[0].c_offset = win->area[0].c_offset;
-			} else {
-				ext_win->area[0].cbr_start = 0;
-				ext_win->area[0].c_offset = 0;
-			}
-		} else {
-			ext_win->area[0].smem_start = win->area[0].smem_start;
-			ext_win->area[0].y_offset = win->area[0].y_offset;
-			if (is_yuv) {
-				ext_win->area[0].cbr_start = win->area[0].cbr_start;
-				ext_win->area[0].c_offset = win->area[0].c_offset;
-			} else {
-				ext_win->area[0].cbr_start = 0;
-				ext_win->area[0].c_offset = 0;
-			}
-		}
-
-		return 0;
-	}
-
-	/* rotate mode */
-	if (!iommu_en) {
-		if (ext_win->id == 0) {
-			ext_win->area[0].smem_start = ext_fb_par->fb_phy_base;
-			ext_win->area[0].y_offset = (get_rotate_fb_size() >> 1) * fb_index;
-			if ((++fb_index) > 1)
-				fb_index = 0;
-		} else {
-			ext_win->area[0].y_offset = 0;
-			last_win = ext_dev_drv->win[ext_win->id - 1];
-			if (last_win->area[0].cbr_start)
-				ext_win->area[0].smem_start =
-					last_win->area[0].cbr_start +
-					last_win->area[0].c_offset +
-					last_win->area[0].xvir * last_win->area[0].yvir;
-			else
-				ext_win->area[0].smem_start =
-					last_win->area[0].smem_start +
-					last_win->area[0].y_offset +
-					last_win->area[0].xvir * last_win->area[0].yvir;
-		}
-
-		if (is_yuv) {
-			ext_win->area[0].cbr_start =
-				ext_win->area[0].smem_start +
-				ext_win->area[0].y_offset +
-				ext_win->area[0].xvir * ext_win->area[0].yvir;
-			ext_win->area[0].c_offset = win->area[0].c_offset;
-		} else {
-			ext_win->area[0].cbr_start = 0;
-			ext_win->area[0].c_offset = 0;
-		}
-	}
-
-	return 0;
-}
+#endif
 
 static int rk_fb_pan_display(struct fb_var_screeninfo *var,
 			     struct fb_info *info)
 {
-	struct rk_fb *rk_fb = dev_get_drvdata(info->device);
 	struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
-	struct rk_fb_par *extend_fb_par = NULL;
 	struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 	struct fb_fix_screeninfo *fix = &info->fix;
-	struct fb_info *extend_info = NULL;
-	struct rk_lcdc_driver *extend_dev_drv = NULL;
-	int win_id = 0, extend_win_id = 0;
-	struct rk_lcdc_win *extend_win = NULL;
+	int win_id = 0;
 	struct rk_lcdc_win *win = NULL;
 	struct rk_screen *screen = dev_drv->cur_screen;
-	int fb_id = 0;
-
 	u32 xoffset = var->xoffset;
 	u32 yoffset = var->yoffset;
 	u32 xvir = var->xres_virtual;
-	/* u32 yvir = var->yres_virtual; */
-	/* u8 data_format = var->nonstd&0xff; */
-
 	u8 pixel_width;
 	u32 vir_width_bit;
 	u32 stride, uv_stride;
@@ -1377,19 +1277,8 @@ static int rk_fb_pan_display(struct fb_var_screeninfo *var,
 	else
 		win = dev_drv->win[win_id];
 
-	if (rk_fb->disp_mode == DUAL) {
-		fb_id = get_extend_fb_id(info);
-		extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
-		extend_fb_par = (struct rk_fb_par *)extend_info->par;
-		extend_dev_drv = extend_fb_par->lcdc_drv;
-		extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
-							   extend_info->fix.id);
-		extend_win = extend_dev_drv->win[extend_win_id];
-	}
-
 	pixel_width = rk_fb_pixel_width(win->area[0].format);
 	vir_width_bit = pixel_width * xvir;
-	/* pixel_width = byte_num * 8 */
 	stride_32bit_1 = ALIGN_N_TIMES(vir_width_bit, 32) / 8;
 	stride_32bit_2 = ALIGN_N_TIMES(vir_width_bit * 2, 32) / 8;
 
@@ -1404,7 +1293,8 @@ static int rk_fb_pan_display(struct fb_var_screeninfo *var,
 		fix->line_length = stride;
 		uv_y_act = win->area[0].yact >> 1;
 		break;
-	case YUV420:		/* 420sp */
+	case YUV420:		/* nv12 */
+	case YUV420_NV21:	/* nv21 */
 	case YUV420_A:
 		is_pic_yuv = 1;
 		stride = stride_32bit_1;
@@ -1431,7 +1321,8 @@ static int rk_fb_pan_display(struct fb_var_screeninfo *var,
 	}
 
 	/* x y mirror ,jump line */
-	if (screen->y_mirror == 1) {
+	if ((screen->y_mirror == 1) ||
+	    (win->mirror_en == 1)) {
 		if (screen->interlace == 1) {
 			win->area[0].y_offset = yoffset * stride * 2 +
 			    ((win->area[0].yact - 1) * 2 + 1) * stride +
@@ -1451,7 +1342,8 @@ static int rk_fb_pan_display(struct fb_var_screeninfo *var,
 		}
 	}
 	if (is_pic_yuv == 1) {
-		if (screen->y_mirror == 1) {
+		if ((screen->y_mirror == 1) ||
+		    (win->mirror_en == 1)) {
 			if (screen->interlace == 1) {
 				win->area[0].c_offset =
 				    uv_y_off * uv_stride * 2 +
@@ -1482,28 +1374,14 @@ static int rk_fb_pan_display(struct fb_var_screeninfo *var,
 
 	dev_drv->ops->pan_display(dev_drv, win_id);
 
-	if (rk_fb->disp_mode == DUAL) {
-		if (extend_info != info && extend_win->state &&
-		    hdmi_switch_complete) {
-			rk_fb_set_ext_win_buffer(extend_win, win,
-						 extend_dev_drv->rotate_mode,
-						 extend_dev_drv->iommu_enabled);
-			if (extend_dev_drv->rotate_mode > X_Y_MIRROR)
-				rk_fb_rotate(extend_info, info);
-
-			extend_dev_drv->ops->pan_display(extend_dev_drv,
-							 extend_win_id);
-			extend_dev_drv->ops->cfg_done(extend_dev_drv);
-		}
-	}
 #ifdef	CONFIG_FB_MIRRORING
 	if (video_data_to_mirroring)
 		video_data_to_mirroring(info, NULL);
 #endif
-	dev_drv->ops->cfg_done(dev_drv);
-	/*msleep(1000);
-	dev_drv->ops->dump_reg(dev_drv);
-	while(1);*/
+        /*if not want the config effect,set reserved[3] bit[0] 1*/
+        if (likely((var->reserved[3] & 0x1) == 0))
+	        dev_drv->ops->cfg_done(dev_drv);
+
 	return 0;
 }
 
@@ -1512,7 +1390,7 @@ static int rk_fb_get_list_stat(struct rk_lcdc_driver *dev_drv)
 	int i, j;
 
 	i = list_empty(&dev_drv->update_regs_list);
-	j = list_empty(&saved_list);
+	j = list_empty(&dev_drv->saved_list);
 	return i == j ? 0 : 1;
 }
 
@@ -1611,9 +1489,6 @@ void rk_fb_free_dma_buf(struct rk_lcdc_driver *dev_drv,
 	int i, index_buf;
 	struct rk_fb_reg_area_data *area_data;
 	struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
-#if defined(CONFIG_ROCKCHIP_IOMMU)
-	struct rk_lcdc_driver *ext_dev_drv = rk_get_extend_lcdc_drv();
-#endif
 
 	for (i = 0; i < reg_win_data->area_num; i++) {
 		area_data = &reg_win_data->reg_area_data[i];
@@ -1621,172 +1496,20 @@ void rk_fb_free_dma_buf(struct rk_lcdc_driver *dev_drv,
 #if defined(CONFIG_ROCKCHIP_IOMMU)
 		if (dev_drv->iommu_enabled) {
 			if (rk_fb->disp_policy != DISPLAY_POLICY_BOX)
-			ion_unmap_iommu(dev_drv->dev, rk_fb->ion_client,
-					area_data->ion_handle);
-			freed_addr[freed_index++] = area_data->smem_start;
-		}
-		if (rk_fb->disp_mode == DUAL && hdmi_switch_complete) {
-			if (ext_dev_drv->iommu_enabled)
-				ion_unmap_iommu(ext_dev_drv->dev,
-						rk_fb->ion_client,
+				ion_unmap_iommu(dev_drv->dev, rk_fb->ion_client,
 						area_data->ion_handle);
+			freed_addr[freed_index++] = area_data->smem_start;
 		}
 #endif
-		if (area_data->ion_handle != NULL) {
-			ion_unmap_kernel(rk_fb->ion_client,
-					 area_data->ion_handle);
+		if (area_data->ion_handle != NULL)
 			ion_free(rk_fb->ion_client, area_data->ion_handle);
-		}
+
 		if (area_data->acq_fence)
 			sync_fence_put(area_data->acq_fence);
 	}
 	memset(reg_win_data, 0, sizeof(struct rk_fb_reg_win_data));
 }
 
-/*
- * function: update extend win info acorrding to primary win info,
-	the function is only used for dual display mode
- * @ext_dev_drv: the extend lcdc driver
- * @dev_drv: the primary lcdc driver
- * @ext_win: the lcdc win info of extend screen
- * @win: the lcdc win info of primary screen
- */
-static int rk_fb_update_ext_win(struct rk_lcdc_driver *ext_dev_drv,
-				     struct rk_lcdc_driver *dev_drv,
-				     struct rk_lcdc_win *ext_win,
-				     struct rk_lcdc_win *win)
-{
-	struct rk_screen *screen = dev_drv->cur_screen;
-	struct rk_screen *ext_screen = ext_dev_drv->cur_screen;
-	int hdmi_xsize = ext_screen->xsize;
-	int hdmi_ysize = ext_screen->ysize;
-	int pixel_width, vir_width_bit, y_stride;
-	bool is_yuv = false;
-	int rotate_mode = 0;
-
-	if (unlikely(!dev_drv) || unlikely(!ext_dev_drv) ||
-	    unlikely(!ext_win) || unlikely(!win))
-                return -1;
-
-	rotate_mode = ext_dev_drv->rotate_mode;
-
-	if (ext_win->state == 0) {
-		dev_info(ext_dev_drv->dev, "extend lcdc win is closed\n");
-		return 0;
-	}
-
-	ext_win->area[0].state = win->area[0].state;
-	ext_win->area[0].format = win->area[0].format;
-	ext_win->area_num = win->area_num;
-	ext_win->fmt_10 = win->fmt_10;
-	ext_win->z_order = win->z_order;
-	ext_win->alpha_en = win->alpha_en;
-	ext_win->alpha_mode = win->alpha_mode;
-	ext_win->g_alpha_val = win->g_alpha_val;
-	ext_win->mirror_en = win->mirror_en;
-	ext_win->area[0].fbdc_en = win->area[0].fbdc_en;
-	ext_win->area[0].fbdc_cor_en = win->area[0].fbdc_cor_en;
-	ext_win->area[0].fbdc_data_format = win->area[0].fbdc_data_format;
-
-	switch (ext_win->area[0].format) {
-	case YUV422:
-	case YUV420:
-	case YUV444:
-	case YUV422_A:
-	case YUV420_A:
-	case YUV444_A:
-		is_yuv = true;
-		break;
-	default:
-		is_yuv = false;
-		break;
-	}
-
-	if (rotate_mode == ROTATE_90 || rotate_mode == ROTATE_270) {
-		ext_win->area[0].xact = win->area[0].yact;
-		ext_win->area[0].yact = win->area[0].xact;
-		ext_win->area[0].xvir = win->area[0].yact;
-		ext_win->area[0].yvir = win->area[0].xact;
-
-		pixel_width = rk_fb_pixel_width(ext_win->area[0].format);
-		vir_width_bit = pixel_width * ext_win->area[0].xvir;
-		y_stride = ALIGN_N_TIMES(vir_width_bit, 32) / 8;
-		ext_win->area[0].y_vir_stride = y_stride >> 2;
-		if (is_yuv)
-			ext_win->area[0].uv_vir_stride = ext_win->area[0].y_vir_stride;
-		else
-			ext_win->area[0].uv_vir_stride = 0;
-	} else {
-		ext_win->area[0].xact = win->area[0].xact;
-		ext_win->area[0].yact = win->area[0].yact;
-		if (win->area[0].xvir == 0)
-			ext_win->area[0].xvir = win->area[0].xact;
-		else
-			ext_win->area[0].xvir = win->area[0].xvir;
-		if (win->area[0].yvir == 0)
-			ext_win->area[0].yvir = win->area[0].yact;
-		else
-			ext_win->area[0].yvir = win->area[0].yvir;
-		ext_win->area[0].y_vir_stride = win->area[0].y_vir_stride;
-		if (is_yuv)
-			ext_win->area[0].uv_vir_stride = win->area[0].uv_vir_stride;
-		else
-			ext_win->area[0].uv_vir_stride = 0;
-	}
-
-	if (win->area[0].xpos != 0 || win->area[0].ypos != 0) {
-		if (rotate_mode == ROTATE_270) {
-			int xbom_pos = 0, ybom_pos = 0;
-			int xtop_pos = 0, ytop_pos = 0;
-
-			ext_win->area[0].xsize =
-				hdmi_xsize * win->area[0].ysize / screen->mode.yres;
-			ext_win->area[0].ysize =
-				hdmi_ysize * win->area[0].xsize / screen->mode.xres;
-			xbom_pos =
-				hdmi_xsize * win->area[0].ypos / screen->mode.yres;
-			ybom_pos = hdmi_ysize * win->area[0].xpos / screen->mode.xres;
-			xtop_pos = hdmi_xsize - ext_win->area[0].xsize - xbom_pos;
-			ytop_pos = hdmi_ysize - ext_win->area[0].ysize - ybom_pos;
-			ext_win->area[0].xpos =
-				((ext_screen->mode.xres - hdmi_xsize) >> 1) + xtop_pos;
-			ext_win->area[0].ypos =
-				((ext_screen->mode.yres - hdmi_ysize) >> 1) + ytop_pos;
-		} else if (rotate_mode == ROTATE_90) {
-			ext_win->area[0].xsize =
-				hdmi_xsize * win->area[0].ysize / screen->mode.yres;
-			ext_win->area[0].ysize =
-				hdmi_ysize * win->area[0].xsize / screen->mode.xres;
-			ext_win->area[0].xpos =
-				((ext_screen->mode.xres - hdmi_xsize) >> 1) +
-				hdmi_xsize * win->area[0].ypos / screen->mode.yres;
-			ext_win->area[0].ypos =
-				((ext_screen->mode.yres - hdmi_ysize) >> 1) +
-				hdmi_ysize * win->area[0].xpos / screen->mode.xres;
-		} else {
-			ext_win->area[0].xsize =
-				hdmi_xsize * win->area[0].xsize / screen->mode.xres;
-			ext_win->area[0].ysize =
-				hdmi_ysize * win->area[0].ysize / screen->mode.yres;
-			ext_win->area[0].xpos =
-				((ext_screen->mode.xres - hdmi_xsize) >> 1) +
-				hdmi_xsize * win->area[0].xpos / screen->mode.xres;
-			ext_win->area[0].ypos =
-				((ext_screen->mode.yres - hdmi_ysize) >> 1) +
-				hdmi_ysize * win->area[0].ypos / screen->mode.yres;
-		}
-	} else {
-		ext_win->area[0].xsize = hdmi_xsize;
-		ext_win->area[0].ysize = hdmi_ysize;
-		ext_win->area[0].xpos =
-			(ext_screen->mode.xres - hdmi_xsize) >> 1;
-		ext_win->area[0].ypos =
-			(ext_screen->mode.yres - hdmi_ysize) >> 1;
-	}
-
-	return 0;
-}
-
 static void rk_fb_update_win(struct rk_lcdc_driver *dev_drv,
                                 struct rk_lcdc_win *win,
 				struct rk_fb_reg_win_data *reg_win_data)
@@ -1837,6 +1560,7 @@ static void rk_fb_update_win(struct rk_lcdc_driver *dev_drv,
 				win->area[i].smem_start =
 					reg_win_data->reg_area_data[i].smem_start;
                                 if (inf->disp_mode == DUAL ||
+                                    inf->disp_mode == NO_DUAL ||
                                     inf->disp_policy == DISPLAY_POLICY_BOX) {
 				        win->area[i].xpos =
 				                reg_win_data->reg_area_data[i].xpos;
@@ -1934,15 +1658,12 @@ static void rk_fb_update_reg(struct rk_lcdc_driver *dev_drv,
 	struct rk_lcdc_win *win;
 	ktime_t timestamp = dev_drv->vsync_info.timestamp;
 	struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
-#if defined(CONFIG_RK_HDMI)
-	struct rk_lcdc_driver *ext_dev_drv;
-	struct rk_lcdc_win *ext_win;
-#endif
 	struct rk_fb_reg_win_data *win_data;
 	bool wait_for_vsync;
 	int count = 100;
 	unsigned int dsp_addr[4];
 	long timeout;
+	int win_status = 0;
 
 	/* acq_fence wait */
 	for (i = 0; i < regs->win_num; i++) {
@@ -1961,6 +1682,7 @@ static void rk_fb_update_reg(struct rk_lcdc_driver *dev_drv,
 		if (win_data) {
 			if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
 			    (win_data->reg_area_data[0].data_format == YUV420 ||
+			     win_data->reg_area_data[0].data_format == YUV420_NV21 ||
 			     win_data->reg_area_data[0].data_format == YUV420_A))
 				continue;
 			mutex_lock(&dev_drv->win_config);
@@ -1981,48 +1703,6 @@ static void rk_fb_update_reg(struct rk_lcdc_driver *dev_drv,
 		}
 	}
 	dev_drv->ops->ovl_mgr(dev_drv, 0, 1);
-	if (rk_fb->disp_policy == DISPLAY_POLICY_BOX)
-		dev_drv->ops->cfg_done(dev_drv);
-#if defined(CONFIG_RK_HDMI)
-	if ((rk_fb->disp_mode == DUAL)
-	    && (hdmi_get_hotplug() == HDMI_HPD_ACTIVED)
-	    && hdmi_switch_complete) {
-                ext_dev_drv = rk_get_extend_lcdc_drv();
-                if (!ext_dev_drv) {
-                        printk(KERN_ERR "hdmi lcdc driver not found!\n");
-                        goto ext_win_exit;
-                }
-
-                /*
-		  * For RK3288: win0 and win1 have only one area and support scale
-		  * but win2 and win3 don't support scale
-		  * so hdmi only use win0 or win1
-		  */
-		for (i = 0; i < 2; i++) {
-		        win = dev_drv->win[i];
-		        ext_win = ext_dev_drv->win[i];
-			ext_win->state = win->state;
-			ext_win->id = win->id;
-			if (!ext_win->state)
-				continue;
-			rk_fb_update_ext_win(ext_dev_drv, dev_drv, ext_win, win);
-			rk_fb_set_ext_win_buffer(ext_win, win,
-						 ext_dev_drv->rotate_mode,
-						 ext_dev_drv->iommu_enabled);
-
-                        if (ext_dev_drv->rotate_mode > X_Y_MIRROR)
-			        rk_fb_win_rotate(ext_win, win,
-			                         ext_dev_drv->rotate_mode,
-						 ext_dev_drv->iommu_enabled);
-
-                        ext_dev_drv->ops->set_par(ext_dev_drv, i);
-		        ext_dev_drv->ops->pan_display(ext_dev_drv, i);
-                }
-
-		ext_dev_drv->ops->cfg_done(ext_dev_drv);
-	}
-ext_win_exit:
-#endif
 	dev_drv->ops->cfg_done(dev_drv);
 
 	do {
@@ -2030,48 +1710,40 @@ ext_win_exit:
 		timeout = wait_event_interruptible_timeout(dev_drv->vsync_info.wait,
 				ktime_compare(dev_drv->vsync_info.timestamp, timestamp) > 0,
 				msecs_to_jiffies(25));
-#if defined(CONFIG_RK_HDMI)
-		if ((rk_fb->disp_mode == DUAL) &&
-		    (hdmi_get_hotplug() == HDMI_HPD_ACTIVED) &&
-		    hdmi_switch_complete) {
-			/*
-			 * If dual output, we need make sure the extend display
-			 * cfg take effect before release fence.
-			 */
-			ext_dev_drv = rk_get_extend_lcdc_drv();
-			timeout = wait_event_interruptible_timeout(ext_dev_drv->vsync_info.wait,
-					ktime_compare(ext_dev_drv->vsync_info.timestamp, timestamp) > 0,
-					msecs_to_jiffies(25));
-		}
-#endif
+
 		dev_drv->ops->get_dsp_addr(dev_drv, dsp_addr);
 		wait_for_vsync = false;
 		for (i = 0; i < dev_drv->lcdc_win_num; i++) {
+                        if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
+			    (!strcmp(dev_drv->win[i]->name, "hwc")))
+			        continue;
 			if (dev_drv->win[i]->state == 1) {
-				if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
-				    (dev_drv->win[i]->area[0].format == YUV420 ||
-				     dev_drv->win[i]->area[0].format == YUV420_A ||
-				     !strcmp(dev_drv->win[i]->name, "hwc"))) {
+				u32 new_start =
+				    dev_drv->win[i]->area[0].smem_start +
+				    dev_drv->win[i]->area[0].y_offset;
+				u32 reg_start = dsp_addr[i];
+
+				if ((rk_fb->disp_policy ==
+				     DISPLAY_POLICY_BOX) &&
+				    (dev_drv->suspend_flag))
 					continue;
-				} else {
-					u32 new_start =
-					    dev_drv->win[i]->area[0].smem_start +
-					    dev_drv->win[i]->area[0].y_offset;
-					u32 reg_start = dsp_addr[i];
-
-					if ((rk_fb->disp_policy ==
-					     DISPLAY_POLICY_BOX) &&
-					    (new_start == 0x0 ||
-					     dev_drv->suspend_flag))
-						continue;
-					if (unlikely(new_start != reg_start)) {
-						wait_for_vsync = true;
-						dev_info(dev_drv->dev,
-						       "win%d:new_addr:0x%08x cur_addr:0x%08x--%d\n",
-						       i, new_start, reg_start, 101 - count);
-						break;
-					}
+				if (unlikely(new_start != reg_start)) {
+					wait_for_vsync = true;
+					dev_info(dev_drv->dev,
+					       "win%d:new_addr:0x%08x cur_addr:0x%08x--%d\n",
+					       i, new_start, reg_start, 101 - count);
+					break;
 				}
+			} else if (dev_drv->win[i]->state == 0) {
+                                if (dev_drv->ops->get_win_state) {
+                                        win_status =
+                                        dev_drv->ops->get_win_state(dev_drv, i);
+                                        if (win_status)
+                                               wait_for_vsync = true;
+                                }
+			} else {
+                                pr_err("!!!win[%d]state:%d,error!!!\n",
+                                        i, dev_drv->win[i]->state);
 			}
 		}
 	} while (wait_for_vsync && count--);
@@ -2116,14 +1788,13 @@ static void rk_fb_update_regs_handler(struct kthread_work *work)
 	struct rk_lcdc_driver *dev_drv =
 	    container_of(work, struct rk_lcdc_driver, update_regs_work);
 	struct rk_fb_reg_data *data, *next;
-	/* struct list_head saved_list; */
 
 	mutex_lock(&dev_drv->update_regs_list_lock);
-	saved_list = dev_drv->update_regs_list;
-	list_replace_init(&dev_drv->update_regs_list, &saved_list);
+	dev_drv->saved_list = dev_drv->update_regs_list;
+	list_replace_init(&dev_drv->update_regs_list, &dev_drv->saved_list);
 	mutex_unlock(&dev_drv->update_regs_list_lock);
 
-	list_for_each_entry_safe(data, next, &saved_list, list) {
+	list_for_each_entry_safe(data, next, &dev_drv->saved_list, list) {
 		rk_fb_update_reg(dev_drv, data);
 		list_del(&data->list);
 	}
@@ -2147,7 +1818,7 @@ static int rk_fb_check_config_var(struct rk_fb_area_par *area_par,
 	if ((area_par->xpos + area_par->xsize > screen->mode.xres) ||
 	    (area_par->ypos + area_par->ysize > screen->mode.yres) ||
 	    (area_par->xsize <= 0) || (area_par->ysize <= 0)) {
-		pr_err("check config var fail 1:\n"
+		pr_warn("check config var fail 1:\n"
 		       "xpos=%d,xsize=%d,xres=%d\n"
 		       "ypos=%d,ysize=%d,yres=%d\n",
 		       area_par->xpos, area_par->xsize, screen->mode.xres,
@@ -2165,8 +1836,8 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 	struct fb_fix_screeninfo *fix = &info->fix;
 	struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
 	struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
-	struct rk_screen *screen = dev_drv->cur_screen;
-        struct rk_screen primary_screen;
+	/*if hdmi size move to hwc,screen should point to cur_screen*/
+	struct rk_screen *screen = dev_drv->screen0;/*cur_screen;*/
 	struct fb_info *fbi;
 	int i, ion_fd, acq_fence_fd;
 	u32 xvir, yvir;
@@ -2186,6 +1857,7 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 	u8 ppixel_a = 0, global_a = 0;
 	ion_phys_addr_t phy_addr;
 	int ret = 0;
+	int buff_len;
 
 	reg_win_data->reg_area_data[0].smem_start = -1;
 	reg_win_data->area_num = 0;
@@ -2203,8 +1875,6 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 					/*return -EINVAL; */
 					break;
 				}
-				fbi->screen_base =
-				    ion_map_kernel(rk_fb->ion_client, hdl);
 				reg_win_data->area_num++;
 				reg_win_data->reg_area_data[i].ion_handle = hdl;
 #ifndef CONFIG_ROCKCHIP_IOMMU
@@ -2229,6 +1899,7 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 				reg_win_data->reg_area_data[i].smem_start = phy_addr;
 				reg_win_data->area_buf_num++;
 				reg_win_data->reg_area_data[i].index_buf = 1;
+				reg_win_data->reg_area_data[i].buff_len = len;
 			}
 		}
 	} else {
@@ -2257,24 +1928,24 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 		reg_win_data->win_id = -1;
 	}
 
-	rk_fb_get_prmry_screen(&primary_screen);
 	reg_win_data->mirror_en = win_par->mirror_en;
-	reg_win_data->reg_area_data[0].fbdc_en = win_par->area_par[0].fbdc_en;
-	reg_win_data->reg_area_data[0].fbdc_cor_en =
-		win_par->area_par[0].fbdc_cor_en;
-	reg_win_data->reg_area_data[0].fbdc_data_format =
-		win_par->area_par[0].fbdc_data_format;
 	for (i = 0; i < reg_win_data->area_num; i++) {
-		if (rk_fb->disp_policy == DISPLAY_POLICY_BOX)
-			rk_fb_check_config_var(&win_par->area_par[i], screen);
-		else
-			rk_fb_check_config_var(&win_par->area_par[i], &primary_screen);
+		rk_fb_check_config_var(&win_par->area_par[i], screen);
 
 		fb_data_fmt = rk_fb_data_fmt(win_par->area_par[i].data_format, 0);
 		reg_win_data->reg_area_data[i].data_format = fb_data_fmt;
+		if (fb_data_fmt >= FBDC_RGB_565) {
+			reg_win_data->reg_area_data[i].fbdc_en = 1;
+			reg_win_data->reg_area_data[i].fbdc_cor_en = 1;
+		} else {
+			reg_win_data->reg_area_data[i].fbdc_en = 0;
+			reg_win_data->reg_area_data[i].fbdc_cor_en = 0;
+		}
 		pixel_width = rk_fb_pixel_width(fb_data_fmt);
 
 		ppixel_a |= ((fb_data_fmt == ARGB888) ||
+			     (fb_data_fmt == FBDC_ARGB_888) ||
+			     (fb_data_fmt == FBDC_ABGR_888) ||
 			     (fb_data_fmt == ABGR888)) ? 1 : 0;
 		/* visiable pos in panel */
 		reg_win_data->reg_area_data[i].xpos = win_par->area_par[i].xpos;
@@ -2334,6 +2005,26 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 				    xoffset * pixel_width / 8;
 			}
 		}
+		if ((fb_data_fmt != YUV420) &&
+		    (fb_data_fmt != YUV420_NV21) &&
+		    (fb_data_fmt != YUV422) &&
+                    (fb_data_fmt != YUV444)) {
+                        buff_len = reg_win_data->reg_area_data[i].y_offset +
+                                reg_win_data->reg_area_data[i].xvir *
+                                reg_win_data->reg_area_data[i].yact *
+                                pixel_width / 8 -
+                                reg_win_data->reg_area_data[i].xoff*
+                                pixel_width / 8;
+                        if (buff_len > reg_win_data->reg_area_data[i].buff_len)
+                                pr_err("\n!!!!!!error: fmt=%d,xvir[%d]*"
+                                       "yact[%d]*bpp[%d]"
+                                       "=buff_len[0x%x]>>mmu len=0x%x\n",
+                                       fb_data_fmt,
+                                       reg_win_data->reg_area_data[i].xvir,
+                                       reg_win_data->reg_area_data[i].yact,
+                                       pixel_width, buff_len,
+                                       reg_win_data->reg_area_data[i].buff_len);
+		}
 	}
 
 	global_a = (win_par->g_alpha_val == 0) ? 0 : 1;
@@ -2352,7 +2043,8 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 		fix->line_length = stride;
 		uv_y_act = win_par->area_par[0].yact >> 1;
 		break;
-	case YUV420:		/* 420sp */
+	case YUV420:		/* nv12 */
+	case YUV420_NV21:	/* nv21 */
 	case YUV420_A:
 		is_pic_yuv = 1;
 		stride = stride_32bit_1;
@@ -2402,6 +2094,23 @@ static int rk_fb_set_win_buffer(struct fb_info *info,
 				    uv_x_off * pixel_width / 8;
 			}
 		}
+		buff_len = reg_win_data->reg_area_data[0].cbr_start +
+			reg_win_data->reg_area_data[0].c_offset +
+			reg_win_data->reg_area_data[0].xvir *
+			reg_win_data->reg_area_data[0].yact *
+			pixel_width / 16 -
+			reg_win_data->reg_area_data[0].smem_start -
+			reg_win_data->reg_area_data[0].xoff*
+			pixel_width / 16 ;
+		if (buff_len > reg_win_data->reg_area_data[0].buff_len)
+			pr_err("\n!!!!!!error: fmt=%d,xvir[%d]*"
+			       "yact[%d]*bpp[%d]"
+			       "=buff_len[0x%x]>>mmu len=0x%x\n",
+			       fb_data_fmt,
+			       reg_win_data->reg_area_data[0].xvir,
+			       reg_win_data->reg_area_data[0].yact,
+			       pixel_width, buff_len,
+			       reg_win_data->reg_area_data[0].buff_len);
 	}
 
 	/* record buffer information for rk_fb_disp_scale to prevent fence timeout
@@ -2428,6 +2137,12 @@ static int rk_fb_set_win_config(struct fb_info *info,
 	int ret = 0, i, j = 0;
 	int list_is_empty = 0;
 
+	if (dev_drv->suspend_flag) {
+		dev_drv->timeline_max++;
+		sw_sync_timeline_inc(dev_drv->timeline, 1);
+		return 0;
+	}
+
 	regs = kzalloc(sizeof(struct rk_fb_reg_data), GFP_KERNEL);
 	if (!regs) {
 		printk(KERN_INFO "could not allocate rk_fb_reg_data\n");
@@ -2461,11 +2176,6 @@ static int rk_fb_set_win_config(struct fb_info *info,
 	}
 
 	mutex_lock(&dev_drv->output_lock);
-	if (!(dev_drv->suspend_flag == 0)) {
-		rk_fb_update_reg(dev_drv, regs);
-		printk(KERN_INFO "suspend_flag = 1\n");
-		goto err;
-	}
 
 	dev_drv->timeline_max++;
 #ifdef H_USE_FENCE
@@ -2494,6 +2204,7 @@ static int rk_fb_set_win_config(struct fb_info *info,
 	win_data->ret_fence_fd = get_unused_fd();
 	if (win_data->ret_fence_fd < 0) {
 		printk("ret_fence_fd=%d\n", win_data->ret_fence_fd);
+		win_data->ret_fence_fd = -1;
 		ret = -EFAULT;
 		goto err;
 	}
@@ -2516,11 +2227,11 @@ static int rk_fb_set_win_config(struct fb_info *info,
 	} else {
 		mutex_lock(&dev_drv->update_regs_list_lock);
 		list_is_empty = list_empty(&dev_drv->update_regs_list) &&
-					list_empty(&saved_list);
+					list_empty(&dev_drv->saved_list);
 		mutex_unlock(&dev_drv->update_regs_list_lock);
 		if (!list_is_empty) {
 			ret = wait_event_timeout(dev_drv->update_regs_wait,
-				list_empty(&dev_drv->update_regs_list) && list_empty(&saved_list),
+				list_empty(&dev_drv->update_regs_list) && list_empty(&dev_drv->saved_list),
 				msecs_to_jiffies(60));
 			if (ret > 0)
 				rk_fb_update_reg(dev_drv, regs);
@@ -2613,13 +2324,8 @@ static int rk_fb_ioctl(struct fb_info *info, unsigned int cmd,
 {
 	struct rk_fb *rk_fb = dev_get_drvdata(info->device);
 	struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
-	struct rk_fb_par *extend_fb_par = NULL;
 	struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 	struct fb_fix_screeninfo *fix = &info->fix;
-	int fb_id = 0, extend_win_id = 0;
-	struct fb_info *extend_info = NULL;
-	struct rk_lcdc_driver *extend_dev_drv = NULL;
-	struct rk_lcdc_win *extend_win = NULL;
 	struct rk_lcdc_win *win;
 	int enable;	/* enable fb:1 enable;0 disable */
 	int ovl;	/* overlay:0 win1 on the top of win0;1,win0 on the top of win1 */
@@ -2633,15 +2339,6 @@ static int rk_fb_ioctl(struct fb_info *info, unsigned int cmd,
 
 	void __user *argp = (void __user *)arg;
 	win = dev_drv->win[win_id];
-	if (rk_fb->disp_mode == DUAL) {
-		fb_id = get_extend_fb_id(info);
-		extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
-		extend_fb_par = (struct rk_fb_par *)extend_info->par;
-		extend_dev_drv = extend_fb_par->lcdc_drv;
-		extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
-							    extend_info->fix.id);
-		extend_win = extend_dev_drv->win[extend_win_id];
-	}
 
 	switch (cmd) {
 	case RK_FBIOSET_HWC_ADDR:
@@ -2664,6 +2361,7 @@ static int rk_fb_ioctl(struct fb_info *info, unsigned int cmd,
 			if (!usr_fd) {
 				fix->smem_start = 0;
 				fix->mmio_start = 0;
+				dev_drv->ops->open(dev_drv, win_id, 0);
 				break;
 			}
 
@@ -2713,7 +2411,6 @@ static int rk_fb_ioctl(struct fb_info *info, unsigned int cmd,
 
 				usr_fd = yuv_phy[0];
 				offset = yuv_phy[1] - yuv_phy[0];
-
 				if (!usr_fd) {
 					fix->smem_start = 0;
 					fix->mmio_start = 0;
@@ -2966,7 +2663,8 @@ static ssize_t rk_fb_read(struct fb_info *info, char __user *buf,
 	/* only read the current frame buffer */
 	if (win->area[0].format == RGB565) {
 		total_size = win->area[0].y_vir_stride * win->area[0].yact << 1;
-	} else if (win->area[0].format == YUV420) {
+	} else if ((win->area[0].format == YUV420) ||
+	           (win->area[0].format == YUV420_NV21)) {
 		total_size =
 		    (win->area[0].y_vir_stride * win->area[0].yact * 6);
 	} else {
@@ -3078,88 +2776,13 @@ static ssize_t rk_fb_write(struct fb_info *info, const char __user *buf,
 	return (cnt) ? cnt : err;
 }
 
-/*
- * function: update extend info acorrding to primary info that only used for dual display mode
- * @ext_info: the fb_info of extend screen
- * @info: the fb_info of primary screen
- * @update_buffer: whether to update extend info buffer, 0: no;1: yes
- */
-static int rk_fb_update_ext_info(struct fb_info *ext_info,
-					struct fb_info *info, int update_buffer)
-{
-	struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
-	struct rk_fb_par *fb_par = NULL;
-	struct rk_fb_par *ext_fb_par = NULL;
-	struct rk_lcdc_driver *dev_drv = NULL;
-	struct rk_lcdc_driver *ext_dev_drv = NULL;
-	struct rk_lcdc_win *win = NULL;
-	struct rk_lcdc_win *ext_win = NULL;
-	int win_id = 0, ext_win_id = 0;
-
-	if (rk_fb->disp_mode != DUAL || info == ext_info)
-		return 0;
-	if (unlikely(!info) || unlikely(!ext_info))
-                return -1;
-
-	fb_par = (struct rk_fb_par *)info->par;
-	ext_fb_par = (struct rk_fb_par *)ext_info->par;
-	dev_drv = fb_par->lcdc_drv;
-	ext_dev_drv = ext_fb_par->lcdc_drv;
-	if (unlikely(!dev_drv) || unlikely(!ext_dev_drv))
-                return -1;
-
-	win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
-	win = dev_drv->win[win_id];
-	ext_win_id = ext_dev_drv->ops->fb_get_win_id(ext_dev_drv,
-						     ext_info->fix.id);
-	ext_win = ext_dev_drv->win[ext_win_id];
-
-	rk_fb_update_ext_win(ext_dev_drv, dev_drv, ext_win, win);
-	if (update_buffer) {
-		rk_fb_set_ext_win_buffer(ext_win, win, ext_dev_drv->rotate_mode,
-					 ext_dev_drv->iommu_enabled);
-
-		/* update extend info display address */
-		ext_info->fix.smem_start = ext_win->area[0].smem_start;
-		ext_info->fix.mmio_start = ext_win->area[0].cbr_start;
-
-		if (ext_dev_drv->rotate_mode > X_Y_MIRROR)
-			rk_fb_rotate(ext_info, info);
-	}
-
-	/* update extend info */
-	ext_info->var.xres = ext_win->area[0].xact;
-	ext_info->var.yres = ext_win->area[0].yact;
-	ext_info->var.xres_virtual = ext_win->area[0].xvir;
-	ext_info->var.yres_virtual = ext_win->area[0].yvir;
-
-	/* config same data format */
-	ext_info->var.nonstd &= 0xffffff00;
-	ext_info->var.nonstd |= (info->var.nonstd & 0xff);
-
-	ext_info->var.nonstd &= 0xff;
-	ext_info->var.nonstd |=
-		(ext_win->area[0].xpos << 8) + (ext_win->area[0].ypos << 20);
-
-	ext_info->var.grayscale &= 0xff;
-	ext_info->var.grayscale |=
-		(ext_win->area[0].xsize << 8) + (ext_win->area[0].ysize << 20);
-
-	return 0;
-}
-
 static int rk_fb_set_par(struct fb_info *info)
 {
 	struct fb_var_screeninfo *var = &info->var;
 	struct fb_fix_screeninfo *fix = &info->fix;
 	struct rk_fb_par *fb_par = (struct rk_fb_par *)info->par;
-	struct rk_fb_par *extend_fb_par = NULL;
 	struct rk_lcdc_driver *dev_drv = fb_par->lcdc_drv;
 	struct rk_fb *rk_fb = dev_get_drvdata(info->device);
-	int fb_id, extend_win_id = 0;
-	struct fb_info *extend_info = NULL;
-	struct rk_lcdc_driver *extend_dev_drv = NULL;
-	struct rk_lcdc_win *extend_win = NULL;
 	struct rk_lcdc_win *win = NULL;
 	struct rk_screen *screen = dev_drv->cur_screen;
 	int win_id = 0;
@@ -3188,16 +2811,6 @@ static int rk_fb_set_par(struct fb_info *info)
 	else
 		win = dev_drv->win[win_id];
 
-	if (rk_fb->disp_mode == DUAL) {
-		fb_id = get_extend_fb_id(info);
-		extend_info = rk_fb->fb[(rk_fb->num_fb >> 1) + fb_id];
-		extend_fb_par = (struct rk_fb_par *)extend_info->par;
-		extend_dev_drv = extend_fb_par->lcdc_drv;
-		extend_win_id = dev_drv->ops->fb_get_win_id(extend_dev_drv,
-							    extend_info->fix.id);
-		extend_win = extend_dev_drv->win[extend_win_id];
-	}
-
 	/* if the application has specific the horizontal and vertical display size */
 	if (var->grayscale >> 8) {
 		xsize = (var->grayscale >> 8) & 0xfff;
@@ -3212,6 +2825,13 @@ static int rk_fb_set_par(struct fb_info *info)
 	}
 
 	fb_data_fmt = rk_fb_data_fmt(data_format, var->bits_per_pixel);
+	if (fb_data_fmt >= FBDC_RGB_565) {
+		win->area[0].fbdc_en = 1;
+		win->area[0].fbdc_cor_en = 1;
+	} else {
+		win->area[0].fbdc_en = 0;
+		win->area[0].fbdc_cor_en = 0;
+	}
 	pixel_width = rk_fb_pixel_width(fb_data_fmt);
 	vir_width_bit = pixel_width * xvir;
 	/* pixel_width = byte_num * 8 */
@@ -3230,7 +2850,8 @@ static int rk_fb_set_par(struct fb_info *info)
 		cblen = crlen = (xvir * yvir) >> 1;
 		uv_y_act = win->area[0].yact >> 1;
 		break;
-	case YUV420:		/* 420sp */
+	case YUV420:		/* nv12 */
+	case YUV420_NV21:	/* nv21 */
 	case YUV420_A:
 		is_pic_yuv = 1;
 		stride = stride_32bit_1;
@@ -3258,51 +2879,6 @@ static int rk_fb_set_par(struct fb_info *info)
 		break;
 	}
 
-	/* x y mirror ,jump line */
-	if (screen->y_mirror == 1) {
-		if (screen->interlace == 1) {
-			win->area[0].y_offset = yoffset * stride * 2 +
-			    ((win->area[0].yact - 1) * 2 + 1) * stride +
-			    xoffset * pixel_width / 8;
-		} else {
-			win->area[0].y_offset = yoffset * stride +
-			    (win->area[0].yact - 1) * stride +
-			    xoffset * pixel_width / 8;
-		}
-	} else {
-		if (screen->interlace == 1) {
-			win->area[0].y_offset =
-			    yoffset * stride * 2 + xoffset * pixel_width / 8;
-		} else {
-			win->area[0].y_offset =
-			    yoffset * stride + xoffset * pixel_width / 8;
-		}
-	}
-	if (is_pic_yuv == 1) {
-		if (screen->y_mirror == 1) {
-			if (screen->interlace == 1) {
-				win->area[0].c_offset =
-				    uv_y_off * uv_stride * 2 +
-				    ((uv_y_act - 1) * 2 + 1) * uv_stride +
-				    uv_x_off * pixel_width / 8;
-			} else {
-				win->area[0].c_offset = uv_y_off * uv_stride +
-				    (uv_y_act - 1) * uv_stride +
-				    uv_x_off * pixel_width / 8;
-			}
-		} else {
-			if (screen->interlace == 1) {
-				win->area[0].c_offset =
-				    uv_y_off * uv_stride * 2 +
-				    uv_x_off * pixel_width / 8;
-			} else {
-				win->area[0].c_offset =
-				    uv_y_off * uv_stride +
-				    uv_x_off * pixel_width / 8;
-			}
-		}
-	}
-
 	win->area[0].format = fb_data_fmt;
 	win->area[0].y_vir_stride = stride >> 2;
 	win->area[0].uv_vir_stride = uv_stride >> 2;
@@ -3320,22 +2896,17 @@ static int rk_fb_set_par(struct fb_info *info)
 	win->area_num = 1;
 	win->alpha_mode = 4;	/* AB_SRC_OVER; */
 	win->alpha_en = ((win->area[0].format == ARGB888) ||
+			 (win->area[0].format == FBDC_ARGB_888) ||
+			 (win->area[0].format == FBDC_ABGR_888) ||
 			 (win->area[0].format == ABGR888)) ? 1 : 0;
 	win->g_alpha_val = 0;
 
 	if (rk_fb->disp_policy == DISPLAY_POLICY_BOX &&
-	    (win->area[0].format == YUV420 || win->area[0].format == YUV420_A))
-	    win->state = 1;
-	if (rk_fb->disp_mode == DUAL) {
-		if (extend_win->state && hdmi_switch_complete) {
-			if (info != extend_info) {
-				rk_fb_update_ext_win(extend_dev_drv, dev_drv,
-						     extend_win, win);
-				extend_dev_drv->ops->set_par(extend_dev_drv,
-							     extend_win_id);
-			}
-		}
-	}
+	    (win->area[0].format == YUV420 ||
+	     win->area[0].format == YUV420_NV21 ||
+	     win->area[0].format == YUV420_A))
+                win->state = 1;
+
 	dev_drv->ops->set_par(dev_drv, win_id);
 
 	return 0;
@@ -3538,9 +3109,7 @@ int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
 {
 	struct rk_fb *rk_fb =  platform_get_drvdata(fb_pdev);
 	struct fb_info *info = NULL;
-	struct fb_info *pmy_info = NULL;
 	struct rk_fb_par *fb_par = NULL;
-	struct rk_fb_par *pmy_fb_par = NULL;
 	struct rk_lcdc_driver *dev_drv = NULL;
 	char name[6] = {0};
 	int i, win_id, load_screen = 0;
@@ -3570,19 +3139,20 @@ int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
 	if (enable == 2 /*&& dev_drv->enable*/)
 		return 0;
 
-	if (rk_fb->disp_mode == ONE_DUAL) {
-		if (dev_drv->ops->dsp_black)
-			dev_drv->ops->dsp_black(dev_drv, 1);
-		if (dev_drv->ops->set_screen_scaler)
-			dev_drv->ops->set_screen_scaler(dev_drv, dev_drv->screen0, 0);
-	} else if (rk_fb->disp_mode == NO_DUAL) {
+	if ((rk_fb->disp_mode == ONE_DUAL) ||
+	    (rk_fb->disp_mode == NO_DUAL)) {
 		if ((dev_drv->ops->backlight_close) &&
 		    (rk_fb->disp_policy != DISPLAY_POLICY_BOX))
 			dev_drv->ops->backlight_close(dev_drv, 1);
 		if (dev_drv->ops->dsp_black)
 			dev_drv->ops->dsp_black(dev_drv, 1);
+		if ((dev_drv->ops->set_screen_scaler) &&
+		    (rk_fb->disp_policy != DISPLAY_POLICY_BOX))
+			dev_drv->ops->set_screen_scaler(dev_drv,
+							dev_drv->screen0, 0);
 	}
-
+	if (dev_drv->uboot_logo && (screen->type != dev_drv->cur_screen->type))
+               dev_drv->uboot_logo = 0;
 	if (!enable) {
 		/* if screen type is different, we do not disable lcdc. */
 		if (dev_drv->cur_screen->type != screen->type)
@@ -3613,6 +3183,8 @@ int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
 		} else if (rk_fb->num_lcdc > 1) {
 			/* If there is more than one lcdc device, we disable
 			   the layer which attached to this device */
+			dev_drv->suspend_flag = 1;
+			flush_kthread_worker(&dev_drv->update_regs_worker);
 			for (i = 0; i < dev_drv->lcdc_win_num; i++) {
 				if (dev_drv->win[i] && dev_drv->win[i]->state)
 					dev_drv->ops->open(dev_drv, i, 0);
@@ -3624,6 +3196,7 @@ int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
 	} else {
 		if (dev_drv->screen1)
 			dev_drv->cur_screen = dev_drv->screen1;
+
 		memcpy(dev_drv->cur_screen, screen, sizeof(struct rk_screen));
 		dev_drv->cur_screen->xsize = dev_drv->cur_screen->mode.xres;
 		dev_drv->cur_screen->ysize = dev_drv->cur_screen->mode.yres;
@@ -3637,25 +3210,17 @@ int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
 			fb_par = (struct rk_fb_par *)info->par;
 			win_id = dev_drv->ops->fb_get_win_id(dev_drv, info->fix.id);
 			if (dev_drv->win[win_id]) {
-				if (rk_fb->disp_mode == DUAL) {
-					pmy_info = rk_fb->fb[i];
-					if (pmy_info != info) {
-						pmy_fb_par =
-							(struct rk_fb_par *)pmy_info->par;
-						fb_par->state = pmy_fb_par->state;
-					}
-				}
 				if (fb_par->state) {
-					if (!dev_drv->win[win_id]->state)
+					if (!dev_drv->win[win_id]->state) {
 						dev_drv->ops->open(dev_drv, win_id, 1);
+						dev_drv->suspend_flag = 0;
+					}
 					if (!load_screen) {
 						dev_drv->ops->load_screen(dev_drv, 1);
 						load_screen = 1;
 					}
 					info->var.activate |= FB_ACTIVATE_FORCE;
-					if (rk_fb->disp_mode == DUAL) {
-						rk_fb_update_ext_info(info, pmy_info, 1);
-					} else if (rk_fb->disp_mode == ONE_DUAL) {
+					if (rk_fb->disp_mode == ONE_DUAL) {
 						info->var.grayscale &= 0xff;
 						info->var.grayscale |=
 							(dev_drv->cur_screen->xsize << 8) +
@@ -3674,7 +3239,8 @@ int rk_fb_switch_screen(struct rk_screen *screen, int enable, int lcdc_id)
 	}
 	hdmi_switch_complete = 1;
 	if ((rk_fb->disp_mode == ONE_DUAL) || (rk_fb->disp_mode == NO_DUAL)) {
-		if (dev_drv->ops->set_screen_scaler)
+		if ((dev_drv->ops->set_screen_scaler) &&
+		    (rk_fb->disp_policy != DISPLAY_POLICY_BOX))
 			dev_drv->ops->set_screen_scaler(dev_drv, dev_drv->screen0, 1);
 		if (dev_drv->ops->dsp_black)
 			dev_drv->ops->dsp_black(dev_drv, 0);
@@ -3744,9 +3310,7 @@ int rk_fb_disp_scale(u8 scale_x, u8 scale_y, u8 lcdc_id)
 		ypos = (screen_y - screen_y * scale_y / 100) >> 1;
 		dev_drv->cur_screen->xsize = screen_x * scale_x / 100;
 		dev_drv->cur_screen->ysize = screen_y * scale_y / 100;
-		if (inf->disp_mode == DUAL) {
-			rk_fb_update_ext_info(info, pmy_info, 0);
-		} else {
+		if (inf->disp_mode == ONE_DUAL) {
 			var->nonstd &= 0xff;
 			var->nonstd |= (xpos << 8) + (ypos << 20);
 			var->grayscale &= 0xff;
@@ -3823,7 +3387,7 @@ err_share_dma_buf:
 }
 #endif
 
-static int rk_fb_alloc_buffer(struct fb_info *fbi, int fb_id)
+static int rk_fb_alloc_buffer(struct fb_info *fbi)
 {
 	struct rk_fb *rk_fb = platform_get_drvdata(fb_pdev);
 	struct rk_fb_par *fb_par = (struct rk_fb_par *)fbi->par;
@@ -3861,39 +3425,10 @@ static int rk_fb_alloc_buffer(struct fb_info *fbi, int fb_id)
 		fbi->screen_base = fb_mem_virt;
 #endif
 		memset(fbi->screen_base, 0, fbi->fix.smem_len);
-		printk(KERN_INFO "fb%d:phy:%lx>>vir:%p>>len:0x%x\n", fb_id,
-		       fbi->fix.smem_start, fbi->screen_base,
-		       fbi->fix.smem_len);
 	} else {
-		if (dev_drv->rotate_mode > X_Y_MIRROR) {
-			fb_mem_size = get_rotate_fb_size();
-#if defined(CONFIG_ION_ROCKCHIP)
-			if (rk_fb_alloc_buffer_by_ion(fbi, win, fb_mem_size) < 0)
-				return -ENOMEM;
-#else
-			fb_mem_virt =
-				dma_alloc_writecombine(fbi->dev,
-						       fb_mem_size,
-						       &fb_mem_phys,
-						       GFP_KERNEL);
-			if (!fb_mem_virt) {
-				pr_err("%s: Failed to allocate framebuffer\n",
-					__func__);
-				return -ENOMEM;
-			}
-			fbi->fix.smem_len = fb_mem_size;
-			fbi->fix.smem_start = fb_mem_phys;
-			fbi->screen_base = fb_mem_virt;
-#endif
-		} else {
-			fbi->fix.smem_start = rk_fb->fb[0]->fix.smem_start;
-			fbi->fix.smem_len = rk_fb->fb[0]->fix.smem_len;
-			fbi->screen_base = rk_fb->fb[0]->screen_base;
-		}
-
-		printk(KERN_INFO "fb%d:phy:%lx>>vir:%p>>len:0x%x\n", fb_id,
-		       fbi->fix.smem_start, fbi->screen_base,
-		       fbi->fix.smem_len);
+		fbi->fix.smem_start = rk_fb->fb[0]->fix.smem_start;
+		fbi->fix.smem_len = rk_fb->fb[0]->fix.smem_len;
+		fbi->screen_base = rk_fb->fb[0]->screen_base;
 	}
 
 	fbi->screen_size = fbi->fix.smem_len;
@@ -3901,6 +3436,9 @@ static int rk_fb_alloc_buffer(struct fb_info *fbi, int fb_id)
 	fb_par->fb_virt_base = fbi->screen_base;
 	fb_par->fb_size = fbi->fix.smem_len;
 
+	pr_info("%s:phy:%lx>>vir:%p>>len:0x%x\n", fbi->fix.id,
+		       fbi->fix.smem_start, fbi->screen_base,
+		       fbi->fix.smem_len);
 	return ret;
 }
 
@@ -3966,7 +3504,7 @@ static int init_lcdc_device_driver(struct rk_fb *rk_fb,
 	dev_drv->screen0 = screen;
 	dev_drv->cur_screen = screen;
 	/* devie use one lcdc + rk61x scaler for dual display */
-	if (rk_fb->disp_mode == ONE_DUAL) {
+	if ((rk_fb->disp_mode == ONE_DUAL) || (rk_fb->disp_mode == NO_DUAL)) {
 		struct rk_screen *screen1 =
 				devm_kzalloc(dev_drv->dev,
 					     sizeof(struct rk_screen),
@@ -4166,6 +3704,9 @@ int rk_fb_register(struct rk_lcdc_driver *dev_drv,
 	/* show logo for primary display device */
 #if !defined(CONFIG_FRAMEBUFFER_CONSOLE)
 	if (dev_drv->prop == PRMRY) {
+		u16 xact, yact;
+		int format;
+		u32 dsp_addr;
 		struct fb_info *main_fbi = rk_fb->fb[0];
 		main_fbi->fbops->fb_open(main_fbi, 1);
 
@@ -4177,11 +3718,11 @@ int rk_fb_register(struct rk_lcdc_driver *dev_drv,
 		}
 #endif
 
-		rk_fb_alloc_buffer(main_fbi, 0);	/* only alloc memory for main fb */
+		rk_fb_alloc_buffer(main_fbi);	/* only alloc memory for main fb */
 		dev_drv->uboot_logo = support_uboot_display();
 
-		if (uboot_logo_offset && uboot_logo_base) {
-			struct rk_lcdc_win *win = dev_drv->win[0];
+		if (dev_drv->uboot_logo &&
+		    uboot_logo_offset && uboot_logo_base) {
 			int width, height, bits;
 			phys_addr_t start = uboot_logo_base + uboot_logo_offset;
 			unsigned int size = uboot_logo_size - uboot_logo_offset;
@@ -4190,6 +3731,9 @@ int rk_fb_register(struct rk_lcdc_driver *dev_drv,
 			char *vaddr;
 			int i = 0;
 
+			if (dev_drv->ops->get_dspbuf_info)
+				dev_drv->ops->get_dspbuf_info(dev_drv, &xact,
+					&yact, &format,	&dsp_addr);
 			nr_pages = size >> PAGE_SHIFT;
 			pages = kzalloc(sizeof(struct page) * nr_pages,
 					GFP_KERNEL);
@@ -4215,36 +3759,82 @@ int rk_fb_register(struct rk_lcdc_driver *dev_drv,
 			}
 			kfree(pages);
 			vunmap(vaddr);
-			if (width > main_fbi->var.xres ||
-			    height > main_fbi->var.yres) {
-				pr_err("ERROR: logo size out of screen range");
+			if (dev_drv->uboot_logo &&
+			    (width != xact || height != yact)) {
+				pr_err("can't support uboot kernel logo use different size [%dx%d] != [%dx%d]\n",
+					xact, yact, width, height);
 				return 0;
 			}
 
-			win->area[0].format = rk_fb_data_fmt(0, bits);
-			win->area[0].y_vir_stride = width * bits >> 5;
-			win->area[0].xpos = (main_fbi->var.xres - width) >> 1;
-			win->area[0].ypos = (main_fbi->var.yres - height) >> 1;
-			win->area[0].xsize = width;
-			win->area[0].ysize = height;
-			win->area[0].xact = width;
-			win->area[0].yact = height;
-			win->area[0].xvir = win->area[0].y_vir_stride;
-			win->area[0].yvir = height;
-			win->area[0].smem_start = main_fbi->fix.smem_start;
-			win->area[0].y_offset = 0;
-
-			win->area_num = 1;
-			win->alpha_mode = 4;
-			win->alpha_en = 0;
-			win->g_alpha_val = 0;
+			if (dev_drv->ops->post_dspbuf) {
+				dev_drv->ops->post_dspbuf(dev_drv,
+					main_fbi->fix.smem_start,
+					rk_fb_data_fmt(0, bits),
+					width, height, width * bits >> 5);
+			}
+			if (dev_drv->iommu_enabled) {
+				rk_fb_poll_wait_frame_complete();
+				if (dev_drv->ops->mmu_en)
+					dev_drv->ops->mmu_en(dev_drv);
+				freed_index = 0;
+			}
 
-			win->state = 1;
-			dev_drv->ops->set_par(dev_drv, 0);
-			dev_drv->ops->pan_display(dev_drv, 0);
-			dev_drv->ops->cfg_done(dev_drv);
+			return 0;
+		} else if (dev_drv->uboot_logo && uboot_logo_base) {
+			u32 start = uboot_logo_base;
+			int logo_len, i=0;
+			unsigned int nr_pages;
+			struct page **pages;
+			char *vaddr;
+
+			dev_drv->ops->get_dspbuf_info(dev_drv, &xact,
+					              &yact, &format,
+						      &start);
+			logo_len = rk_fb_pixel_width(format) * xact * yact >> 3;
+			if (logo_len > uboot_logo_size ||
+			    logo_len > main_fbi->fix.smem_len) {
+				pr_err("logo size > uboot reserve buffer size\n");
+				return -1;
+			}
 
+			nr_pages = uboot_logo_size >> PAGE_SHIFT;
+			pages = kzalloc(sizeof(struct page) * nr_pages,
+					GFP_KERNEL);
+			while (i < nr_pages) {
+				pages[i] = phys_to_page(start);
+				start += PAGE_SIZE;
+				i++;
+			}
+			vaddr = vmap(pages, nr_pages, VM_MAP,
+					pgprot_writecombine(PAGE_KERNEL));
+			if (!vaddr) {
+				pr_err("failed to vmap phy addr 0x%llx\n",
+				       uboot_logo_base);
+				return -1;
+			}
+
+			memcpy(main_fbi->screen_base, vaddr, logo_len);
+
+			kfree(pages);
+			vunmap(vaddr);
+
+			dev_drv->ops->post_dspbuf(dev_drv,
+					main_fbi->fix.smem_start,
+					format,	xact, yact,
+					xact * rk_fb_pixel_width(format) >> 5);
+			if (dev_drv->iommu_enabled) {
+				rk_fb_poll_wait_frame_complete();
+				if (dev_drv->ops->mmu_en)
+					dev_drv->ops->mmu_en(dev_drv);
+				freed_index = 0;
+			}
 			return 0;
+		} else {
+			if (dev_drv->iommu_enabled) {
+				if (dev_drv->ops->mmu_en)
+					dev_drv->ops->mmu_en(dev_drv);
+				freed_index = 0;
+			}
 		}
 #if defined(CONFIG_LOGO)
 		main_fbi->fbops->fb_set_par(main_fbi);
@@ -4263,9 +3853,8 @@ int rk_fb_register(struct rk_lcdc_driver *dev_drv,
 #endif
 	} else {
 		struct fb_info *extend_fbi = rk_fb->fb[rk_fb->num_fb >> 1];
-		int extend_fb_id = get_extend_fb_id(extend_fbi);
 
-		rk_fb_alloc_buffer(extend_fbi, extend_fb_id);
+		rk_fb_alloc_buffer(extend_fbi);
 	}
 #endif
 	return 0;