} while (0)
static struct rk_lcdc_win rk322x_vop_win[] = {
- { .name = "win0", .id = VOP_WIN0},
- { .name = "win1", .id = VOP_WIN1},
- { .name = "hwc", .id = VOP_HWC}
+ { .name = "win0",
+ .id = VOP_WIN0,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_SCALE | SUPPORT_YUV |
+ SUPPORT_YUV10BIT,
+ .property.max_input_x = 4096,
+ .property.max_input_y = 2304},
+ { .name = "win1",
+ .id = VOP_WIN1,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_SCALE | SUPPORT_YUV |
+ SUPPORT_YUV10BIT,
+ .property.max_input_x = 4096,
+ .property.max_input_y = 2304},
+ {
+ .name = "hwc",
+ .id = VOP_HWC,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_HWC_LAYER,
+ .property.max_input_x = 128,
+ .property.max_input_y = 128
+ }
};
static struct rk_lcdc_win rk3399_vop_win[] = {
- { .name = "win0", .id = VOP_WIN0},
- { .name = "win1", .id = VOP_WIN1},
- { .name = "win2", .id = VOP_WIN2},
- { .name = "win3", .id = VOP_WIN3},
- { .name = "hwc", .id = VOP_HWC}
+ { .name = "win0",
+ .id = VOP_WIN0,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_SCALE | SUPPORT_YUV |
+ SUPPORT_YUV10BIT,
+ .property.max_input_x = 4096,
+ .property.max_input_y = 2304},
+ { .name = "win1",
+ .id = VOP_WIN1,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_SCALE | SUPPORT_YUV |
+ SUPPORT_YUV10BIT,
+ .property.max_input_x = 4096,
+ .property.max_input_y = 2304},
+ { .name = "win2",
+ .id = VOP_WIN2,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_MULTI_AREA,
+ .property.max_input_x = 4096,
+ .property.max_input_y = 2304},
+ { .name = "win3",
+ .id = VOP_WIN3,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_MULTI_AREA,
+ .property.max_input_x = 4096,
+ .property.max_input_y = 2304},
+ {
+ .name = "hwc",
+ .id = VOP_HWC,
+ .property.feature = SUPPORT_WIN_IDENTIFY | SUPPORT_HW_EXIST |
+ SUPPORT_HWC_LAYER,
+ .property.max_input_x = 128,
+ .property.max_input_y = 128
+ }
};
static const struct vop_data rk322x_data = {
clk_prepare_enable(vop_dev->hclk_noc);
if (vop_dev->aclk_noc)
clk_prepare_enable(vop_dev->aclk_noc);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ pm_runtime_get_sync(vop_dev->dev);
+#endif
spin_lock(&vop_dev->reg_lock);
vop_dev->clk_on = 1;
spin_unlock(&vop_dev->reg_lock);
vop_dev->clk_on = 0;
spin_unlock(&vop_dev->reg_lock);
mdelay(25);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ pm_runtime_put(vop_dev->dev);
+#endif
clk_disable_unprepare(vop_dev->dclk);
clk_disable_unprepare(vop_dev->hclk);
clk_disable_unprepare(vop_dev->aclk);
{
struct vop_device *vop_dev =
container_of(drv, struct vop_device, driver);
+
+ drv->win[win_id]->state = en;
if (win_id == 0)
win0_enable(vop_dev, en);
else if (win_id == 1)
vop_writel(vop_dev, FRC_LOWER11_0, 0xdeb77deb);
vop_writel(vop_dev, FRC_LOWER11_1, 0xed7bb7de);
- vop_msk_reg(vop_dev, SYS_CTRL, V_AUTO_GATING_EN(0));
+ vop_msk_reg(vop_dev, SYS_CTRL, V_AUTO_GATING_EN(1));
vop_msk_reg(vop_dev, DSP_CTRL1, V_DITHER_UP_EN(1));
vop_cfg_done(vop_dev);
vop_dev->pre_init = true;
} else if (win->colorspace == CSC_BT2020) {
val |= V_WIN0_YUV2YUV_EN(1);
LOAD_CSC(vop_dev, Y2R, csc_y2r_bt2020, i);
- LOAD_CSC(vop_dev, 3x3, csc_r2r_bt2020to709, i);
+ LOAD_CSC(vop_dev, R2R, csc_r2r_bt2020to709, i);
}
} else if (output_color == COLOR_YCBCR ||
output_color == COLOR_YCBCR_BT709) {
if (!(IS_YUV(win->area[0].fmt_cfg) ||
win->area[0].yuyv_fmt)) {
val |= V_WIN0_YUV2YUV_R2Y_EN(1);
- LOAD_CSC(vop_dev, R2Y, csc_r2y_bt709_full, i);
+ LOAD_CSC(vop_dev, R2Y, csc_r2y_bt709_full_10, i);
} else if (win->colorspace == CSC_BT2020) {
val |= V_WIN0_YUV2YUV_EN(1) |
V_WIN0_YUV2YUV_Y2R_EN(1) |
V_WIN0_YUV2YUV_R2Y_EN(1);
- LOAD_CSC(vop_dev, R2Y, csc_y2r_bt2020, i);
- LOAD_CSC(vop_dev, R2Y, csc_r2r_bt2020to709, i);
- LOAD_CSC(vop_dev, R2Y, csc_r2y_bt709_full, i);
+ LOAD_CSC(vop_dev, Y2R, csc_y2r_bt2020, i);
+ LOAD_CSC(vop_dev, R2R, csc_r2r_bt2020to709, i);
+ LOAD_CSC(vop_dev, R2Y, csc_r2y_bt709_full_10, i);
}
} else if (output_color == COLOR_YCBCR_BT2020) {
if (!(IS_YUV(win->area[0].fmt_cfg) ||
win->area[0].yuyv_fmt)) {
val |= V_WIN0_YUV2YUV_R2Y_EN(1) |
V_WIN0_YUV2YUV_EN(1);
- LOAD_CSC(vop_dev, R2Y, csc_r2r_bt709to2020, i);
+ LOAD_CSC(vop_dev, R2R, csc_r2r_bt709to2020, i);
LOAD_CSC(vop_dev, R2Y, csc_r2y_bt2020, i);
} else if (win->colorspace == CSC_BT601 ||
win->colorspace == CSC_BT709) {
val |= V_WIN0_YUV2YUV_Y2R_EN(1) |
V_WIN0_YUV2YUV_R2Y_EN(1) |
V_WIN0_YUV2YUV_EN(1);
- LOAD_CSC(vop_dev, R2Y, csc_y2r_bt709_full, i);
- LOAD_CSC(vop_dev, R2Y, csc_r2r_bt709to2020, i);
+ LOAD_CSC(vop_dev, Y2R, csc_y2r_bt709_full_10, i);
+ LOAD_CSC(vop_dev, R2R, csc_r2r_bt709to2020, i);
LOAD_CSC(vop_dev, R2Y, csc_r2y_bt2020, i);
}
}
struct vop_device *vop_dev =
container_of(dev_drv, struct vop_device, driver);
int output_color = dev_drv->output_color;
- int win_csc, overlay_mode;
+ int win_csc = 0, overlay_mode = 0;
u64 val;
if (VOP_CHIP(vop_dev) == VOP_RK322X) {
struct alpha_config alpha_config;
u64 val;
int ppixel_alpha = 0, global_alpha = 0, i;
- u32 src_alpha_ctl, dst_alpha_ctl;
+ u32 src_alpha_ctl = 0, dst_alpha_ctl = 0;
int alpha_en = 1;
+ memset(&alpha_config, 0, sizeof(struct alpha_config));
for (i = 0; i < win->area_num; i++) {
ppixel_alpha |= ((win->area[i].format == ARGB888) ||
(win->area[i].format == FBDC_ARGB_888) ||
static int vop_fbdc_reg_update(struct vop_device *vop_dev, int win_id)
{
struct rk_lcdc_win *win = vop_dev->driver.win[win_id];
- u32 val;
+ u64 val;
val = V_VOP_FBDC_WIN_SEL(win_id) |
V_AFBCD_HREG_PIXEL_PACKING_FMT(win->area[0].fbdc_fmt_cfg) |
return 0;
}
- win->area[0].fbdc_mb_width = win->area[0].xact;
+ win->area[0].fbdc_mb_width = win->area[0].xvir;
win->area[0].fbdc_mb_height = win->area[0].yact;
win->area[0].fbdc_cor_en = 0; /* hreg_block_split */
- win->area[0].fbdc_fmt_cfg |= 0 << 4;
+ win->area[0].fbdc_fmt_cfg |= AFBDC_YUV_COLOR_TRANSFORM << 4;
return 0;
}
u64 val;
u32 off;
int format;
+ struct rk_win_property *win_property =
+ &dev_drv->win[win_id]->property;
off = win_id * 0x40;
if (win->state == 1) {
+ if (!(win_property->feature & SUPPORT_HW_EXIST)) {
+ pr_err("vop[%d] win[%d] hardware unsupport\n",
+ vop_dev->id, win_id);
+ return 0;
+ }
vop_axi_gather_cfg(vop_dev, win);
if (win->area[0].fbdc_en)
vop_fbdc_reg_update(vop_dev, win_id);
val = V_WIN0_HS_FACTOR_CBR(win->scale_cbcr_x) |
V_WIN0_VS_FACTOR_CBR(win->scale_cbcr_y);
vop_writel(vop_dev, WIN0_SCL_FACTOR_CBR + off, val);
- if (win->alpha_en == 1) {
- vop_alpha_cfg(dev_drv, win_id);
- } else {
- val = V_WIN0_SRC_ALPHA_EN(0);
- vop_msk_reg(vop_dev, WIN0_SRC_ALPHA_CTRL + off, val);
- }
-
} else {
val = V_WIN0_EN(win->state);
vop_msk_reg(vop_dev, WIN0_CTRL0 + off, val);
struct rk_lcdc_win *win = dev_drv->win[win_id];
unsigned int off;
u64 val;
+ struct rk_win_property *win_property =
+ &dev_drv->win[win_id]->property;
off = (win_id - 2) * 0x50;
area_xst(win, win->area_num);
if (win->state == 1) {
+ if (!(win_property->feature & SUPPORT_HW_EXIST)) {
+ pr_err("vop[%d] win[%d] hardware unsupport\n",
+ vop_dev->id, win_id);
+ return 0;
+ }
vop_axi_gather_cfg(vop_dev, win);
if (win->area[0].fbdc_en)
vop_fbdc_reg_update(vop_dev, win_id);
val = V_WIN2_VIR_STRIDE0(win->area[0].y_vir_stride);
vop_msk_reg(vop_dev, WIN2_VIR0_1 + off, val);
- val = V_WIN2_DSP_WIDTH0(win->area[0].xsize) |
- V_WIN2_DSP_HEIGHT0(win->area[0].ysize);
+ val = V_WIN2_DSP_WIDTH0(win->area[0].xsize - 1) |
+ V_WIN2_DSP_HEIGHT0(win->area[0].ysize - 1);
vop_writel(vop_dev, WIN2_DSP_INFO0 + off, val);
val = V_WIN2_DSP_XST0(win->area[0].dsp_stx) |
V_WIN2_DSP_YST0(win->area[0].dsp_sty);
val = V_WIN2_VIR_STRIDE1(win->area[1].y_vir_stride);
vop_msk_reg(vop_dev, WIN2_VIR0_1 + off, val);
- val = V_WIN2_DSP_WIDTH1(win->area[1].xsize) |
- V_WIN2_DSP_HEIGHT1(win->area[1].ysize);
+ val = V_WIN2_DSP_WIDTH1(win->area[1].xsize - 1) |
+ V_WIN2_DSP_HEIGHT1(win->area[1].ysize - 1);
vop_writel(vop_dev, WIN2_DSP_INFO1 + off, val);
val = V_WIN2_DSP_XST1(win->area[1].dsp_stx) |
V_WIN2_DSP_YST1(win->area[1].dsp_sty);
val = V_WIN2_VIR_STRIDE2(win->area[2].y_vir_stride);
vop_msk_reg(vop_dev, WIN2_VIR2_3 + off, val);
- val = V_WIN2_DSP_WIDTH2(win->area[2].xsize) |
- V_WIN2_DSP_HEIGHT2(win->area[2].ysize);
+ val = V_WIN2_DSP_WIDTH2(win->area[2].xsize - 1) |
+ V_WIN2_DSP_HEIGHT2(win->area[2].ysize - 1);
vop_writel(vop_dev, WIN2_DSP_INFO2 + off, val);
val = V_WIN2_DSP_XST2(win->area[2].dsp_stx) |
V_WIN2_DSP_YST2(win->area[2].dsp_sty);
val = V_WIN2_VIR_STRIDE3(win->area[3].y_vir_stride);
vop_msk_reg(vop_dev, WIN2_VIR2_3 + off, val);
- val = V_WIN2_DSP_WIDTH3(win->area[3].xsize) |
- V_WIN2_DSP_HEIGHT3(win->area[3].ysize);
+ val = V_WIN2_DSP_WIDTH3(win->area[3].xsize - 1) |
+ V_WIN2_DSP_HEIGHT3(win->area[3].ysize - 1);
vop_writel(vop_dev, WIN2_DSP_INFO3 + off, val);
val = V_WIN2_DSP_XST3(win->area[3].dsp_stx) |
V_WIN2_DSP_YST3(win->area[3].dsp_sty);
val = V_WIN2_MST3_EN(0);
vop_msk_reg(vop_dev, WIN2_CTRL0 + off, val);
}
-
- if (win->alpha_en == 1) {
- vop_alpha_cfg(dev_drv, win_id);
- } else {
- val = V_WIN2_SRC_ALPHA_EN(0);
- vop_msk_reg(vop_dev, WIN2_SRC_ALPHA_CTRL + off, val);
- }
} else {
val = V_WIN2_EN(win->state) | V_WIN2_MST0_EN(0) |
V_WIN2_MST1_EN(0) | V_WIN2_MST2_EN(0) | V_WIN2_MST3_EN(0);
unsigned int hwc_size = 0;
u64 val;
+ if ((win->area[0].xsize == 32) && (win->area[0].ysize == 32)) {
+ hwc_size = 0;
+ } else if ((win->area[0].xsize == 64) && (win->area[0].ysize == 64)) {
+ hwc_size = 1;
+ } else if ((win->area[0].xsize == 96) && (win->area[0].ysize == 96)) {
+ hwc_size = 2;
+ } else if ((win->area[0].xsize == 128) &&
+ (win->area[0].ysize == 128)) {
+ hwc_size = 3;
+ } else {
+ dev_err(vop_dev->dev, "un supported hwc size[%dx%d]!\n",
+ win->area[0].xsize, win->area[0].ysize);
+ return -EINVAL;
+ }
+
if (win->state == 1) {
vop_axi_gather_cfg(vop_dev, win);
val = V_HWC_EN(1) | V_HWC_DATA_FMT(win->area[0].fmt_cfg) |
V_HWC_RB_SWAP(win->area[0].swap_rb);
vop_msk_reg(vop_dev, HWC_CTRL0, val);
- if ((win->area[0].xsize == 32) && (win->area[0].ysize == 32))
- hwc_size = 0;
- else if ((win->area[0].xsize == 64) &&
- (win->area[0].ysize == 64))
- hwc_size = 1;
- else if ((win->area[0].xsize == 96) &&
- (win->area[0].ysize == 96))
- hwc_size = 2;
- else if ((win->area[0].xsize == 128) &&
- (win->area[0].ysize == 128))
- hwc_size = 3;
- else
- dev_err(vop_dev->dev, "un supported hwc size[%dx%d]!\n",
- win->area[0].xsize, win->area[0].ysize);
-
val = V_HWC_SIZE(hwc_size);
vop_msk_reg(vop_dev, HWC_CTRL0, val);
val = V_HWC_DSP_XST(win->area[0].dsp_stx) |
V_HWC_DSP_YST(win->area[0].dsp_sty);
vop_msk_reg(vop_dev, HWC_DSP_ST, val);
-
- if (win->alpha_en == 1) {
- vop_alpha_cfg(dev_drv, win_id);
- } else {
- val = V_WIN2_SRC_ALPHA_EN(0);
- vop_msk_reg(vop_dev, HWC_SRC_ALPHA_CTRL, val);
- }
} else {
val = V_HWC_EN(win->state);
vop_msk_reg(vop_dev, HWC_CTRL0, val);
vop_msk_reg(vop_dev, LINE_FLAG, val);
}
vop_post_cfg(dev_drv);
+ if ((x_res <= VOP_INPUT_MAX_WIDTH / 2) && (vop_dev->id == 0))
+ vop_msk_reg(vop_dev, SYS_CTRL, V_POST_LB_MODE(1));
+ else
+ vop_msk_reg(vop_dev, SYS_CTRL, V_POST_LB_MODE(0));
return 0;
}
struct vop_device *vop_dev =
container_of(dev_drv, struct vop_device, driver);
struct rk_screen *screen = dev_drv->cur_screen;
- u64 val;
+ u64 val = 0;
if (unlikely(!vop_dev->clk_on)) {
pr_info("%s,clk_on = %d\n", __func__, vop_dev->clk_on);
V_DITHER_DOWN_SEL(0) |
V_DITHER_DOWN_MODE(0);
break;
+ case OUT_YUV_422:
+ face = OUT_YUV_422;
+ val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1) |
+ V_PRE_DITHER_DOWN_EN(1) |
+ V_DITHER_DOWN_SEL(0) |
+ V_DITHER_DOWN_MODE(0);
+ break;
+ case OUT_YUV_422_10BIT:
+ face = OUT_YUV_422;
+ val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1) |
+ V_PRE_DITHER_DOWN_EN(0) |
+ V_DITHER_DOWN_SEL(0) |
+ V_DITHER_DOWN_MODE(0);
+ break;
case OUT_P101010:
face = OUT_P101010;
val = V_DITHER_DOWN_EN(0) | V_DITHER_UP_EN(1) |
vop_msk_reg(vop_dev, SYS_CTRL, val);
break;
case SCREEN_HDMI:
+ if ((VOP_CHIP(vop_dev) == VOP_RK3399) &&
+ ((screen->face == OUT_P888) ||
+ (screen->face == OUT_P101010))) {
+ if (vop_dev->id == 0)
+ face = OUT_P101010; /*RGB 10bit output*/
+ else
+ face = OUT_P888;
+ }
val = V_HDMI_OUT_EN(1) | V_SW_UV_OFFSET_EN(0);
vop_msk_reg(vop_dev, SYS_CTRL, val);
+ val = V_HDMI_HSYNC_POL(screen->pin_hsync) |
+ V_HDMI_VSYNC_POL(screen->pin_vsync) |
+ V_HDMI_DEN_POL(screen->pin_den) |
+ V_HDMI_DCLK_POL(screen->pin_dclk);
+ /*hsync vsync den dclk polo,dither */
+ vop_msk_reg(vop_dev, DSP_CTRL1, val);
break;
case SCREEN_RGB:
case SCREEN_LVDS:
val = V_RGB_OUT_EN(1);
vop_msk_reg(vop_dev, SYS_CTRL, val);
+ break;
case SCREEN_MIPI:
val = V_MIPI_OUT_EN(1);
vop_msk_reg(vop_dev, SYS_CTRL, val);
+ val = V_MIPI_HSYNC_POL(screen->pin_hsync) |
+ V_MIPI_VSYNC_POL(screen->pin_vsync) |
+ V_MIPI_DEN_POL(screen->pin_den) |
+ V_MIPI_DCLK_POL(screen->pin_dclk);
+ /*hsync vsync den dclk polo,dither */
+ vop_msk_reg(vop_dev, DSP_CTRL1, val);
+ break;
+ case SCREEN_DUAL_MIPI:
+ val = V_MIPI_OUT_EN(1) | V_MIPI_DUAL_CHANNEL_EN(1);
+ vop_msk_reg(vop_dev, SYS_CTRL, val);
+ val = V_MIPI_HSYNC_POL(screen->pin_hsync) |
+ V_MIPI_VSYNC_POL(screen->pin_vsync) |
+ V_MIPI_DEN_POL(screen->pin_den) |
+ V_MIPI_DCLK_POL(screen->pin_dclk);
+ /*hsync vsync den dclk polo,dither */
+ vop_msk_reg(vop_dev, DSP_CTRL1, val);
+ break;
case SCREEN_EDP:
+ if ((VOP_CHIP(vop_dev) == VOP_RK3399) &&
+ (vop_dev->id == 0))
+ face = OUT_P101010;
val = V_EDP_OUT_EN(1);
vop_msk_reg(vop_dev, SYS_CTRL, val);
+ val = V_EDP_HSYNC_POL(screen->pin_hsync) |
+ V_EDP_VSYNC_POL(screen->pin_vsync) |
+ V_EDP_DEN_POL(screen->pin_den) |
+ V_EDP_DCLK_POL(screen->pin_dclk);
+ /*hsync vsync den dclk polo,dither */
+ vop_msk_reg(vop_dev, DSP_CTRL1, val);
+ break;
+ case SCREEN_DP:
+ dclk_ddr = 0;
+ if ((VOP_CHIP(vop_dev) == VOP_RK3399) &&
+ ((screen->face == OUT_P888) ||
+ (screen->face == OUT_P101010))) {
+ if (vop_dev->id == 0)
+ face = OUT_P101010;
+ else
+ face = OUT_P888;
+ }
+ val = V_DP_OUT_EN(1);
+ vop_msk_reg(vop_dev, SYS_CTRL, val);
+ val = V_DP_HSYNC_POL(screen->pin_hsync) |
+ V_DP_VSYNC_POL(screen->pin_vsync) |
+ V_DP_DEN_POL(screen->pin_den) |
+ V_DP_DCLK_POL(screen->pin_dclk);
+ /*hsync vsync den dclk polo,dither */
+ vop_msk_reg(vop_dev, DSP_CTRL1, val);
break;
default:
dev_err(vop_dev->dev, "un supported interface[%d]!\n",
screen->type);
break;
}
- val = V_HDMI_HSYNC_POL(screen->pin_hsync) |
- V_HDMI_VSYNC_POL(screen->pin_vsync) |
- V_HDMI_DEN_POL(screen->pin_den) |
- V_HDMI_DCLK_POL(screen->pin_dclk);
- /*hsync vsync den dclk polo,dither */
- vop_msk_reg(vop_dev, DSP_CTRL1, val);
if (screen->color_mode == COLOR_RGB)
dev_drv->overlay_mode = VOP_RGB_DOMAIN;
return 0;
}
+static int vop_early_suspend(struct rk_lcdc_driver *dev_drv);
+static int vop_early_resume(struct rk_lcdc_driver *dev_drv);
/*enable layer,open:1,enable;0 disable*/
static void vop_layer_enable(struct vop_device *vop_dev,
unsigned int win_id, bool open)
vop_dev->driver.win[win_id]);
vop_cfg_done(vop_dev);
}
- /* if no layer used,disable lcdc */
- if (!vop_dev->atv_layer_cnt) {
+ }
+ spin_unlock(&vop_dev->reg_lock);
+ /* if no layer used,disable lcdc */
+ if (vop_dev->prop == EXTEND) {
+ if (!vop_dev->atv_layer_cnt && !open) {
+ vop_early_suspend(&vop_dev->driver);
dev_info(vop_dev->dev,
"no layer is used,go to standby!\n");
vop_dev->standby = 1;
+ } else if (open) {
+ vop_early_resume(&vop_dev->driver);
+ dev_info(vop_dev->dev, "wake up from standby!\n");
}
}
- spin_unlock(&vop_dev->reg_lock);
+
}
static int vop_enable_irq(struct rk_lcdc_driver *dev_drv)
val = INTR_FS | INTR_LINE_FLAG0 | INTR_BUS_ERROR | INTR_LINE_FLAG1 |
INTR_WIN0_EMPTY | INTR_WIN1_EMPTY | INTR_HWC_EMPTY |
INTR_POST_BUF_EMPTY;
+ val |= val << 16;
- vop_mask_writel(vop_dev, INTR_EN0, INTR_MASK, val);
+ vop_msk_reg(vop_dev, INTR_EN0, val);
return 0;
}
static int vop_cal_scl_fac(struct rk_lcdc_win *win, struct rk_screen *screen)
{
- u16 srcW;
- u16 srcH;
- u16 dstW;
- u16 dstH;
- u16 yrgb_srcW;
- u16 yrgb_srcH;
- u16 yrgb_dstW;
- u16 yrgb_dstH;
- u32 yrgb_vscalednmult;
- u32 yrgb_xscl_factor;
- u32 yrgb_yscl_factor;
+ u16 srcW = 0;
+ u16 srcH = 0;
+ u16 dstW = 0;
+ u16 dstH = 0;
+ u16 yrgb_srcW = 0;
+ u16 yrgb_srcH = 0;
+ u16 yrgb_dstW = 0;
+ u16 yrgb_dstH = 0;
+ u32 yrgb_vscalednmult = 0;
+ u32 yrgb_xscl_factor = 0;
+ u32 yrgb_yscl_factor = 0;
u8 yrgb_vsd_bil_gt2 = 0;
u8 yrgb_vsd_bil_gt4 = 0;
- u16 cbcr_srcW;
- u16 cbcr_srcH;
- u16 cbcr_dstW;
- u16 cbcr_dstH;
- u32 cbcr_vscalednmult;
- u32 cbcr_xscl_factor;
- u32 cbcr_yscl_factor;
+ u16 cbcr_srcW = 0;
+ u16 cbcr_srcH = 0;
+ u16 cbcr_dstW = 0;
+ u16 cbcr_dstH = 0;
+ u32 cbcr_vscalednmult = 0;
+ u32 cbcr_xscl_factor = 0;
+ u32 cbcr_yscl_factor = 0;
u8 cbcr_vsd_bil_gt2 = 0;
u8 cbcr_vsd_bil_gt4 = 0;
u8 yuv_fmt = 0;
static int win_0_1_set_par(struct vop_device *vop_dev,
struct rk_screen *screen, struct rk_lcdc_win *win)
{
- u32 xact, yact, xvir, yvir, xpos, ypos;
- u8 fmt_cfg = 0, swap_rb, swap_uv = 0;
+ u32 xact = 0, yact = 0, xvir = 0, yvir = 0, xpos = 0, ypos = 0;
+ u8 fmt_cfg = 0, swap_rb = 0, swap_uv = 0;
char fmt[9] = "NULL";
xpos = dsp_x_pos(win->xmirror, screen, &win->area[0]);
struct rk_screen *screen, struct rk_lcdc_win *win)
{
int i;
- u8 fmt_cfg, swap_rb;
+ u8 fmt_cfg = 0, swap_rb = 0;
char fmt[9] = "NULL";
if (VOP_CHIP(vop_dev) == VOP_RK322X) {
static int hwc_set_par(struct vop_device *vop_dev,
struct rk_screen *screen, struct rk_lcdc_win *win)
{
- u32 xact, yact, xvir, yvir, xpos, ypos;
- u8 fmt_cfg = 0, swap_rb;
+ u32 xact = 0, yact = 0, xvir = 0, yvir = 0, xpos = 0, ypos = 0;
+ u8 fmt_cfg = 0, swap_rb = 0;
char fmt[9] = "NULL";
xpos = win->area[0].xpos + screen->mode.left_margin +
return 0;
}
wb_data = &dev_drv->wb_data;
+ if ((wb_data->xsize == 0) || (wb_data->ysize == 0))
+ return 0;
xsize = wb_data->xsize;
ysize = wb_data->ysize;
switch (wb_data->data_format) {
case ARGB888:
+ case ABGR888:
+ case XRGB888:
+ case XBGR888:
fmt_cfg = 0;
break;
case RGB888:
+ case BGR888:
fmt_cfg = 1;
break;
case RGB565:
+ case BGR565:
fmt_cfg = 2;
break;
case YUV420:
struct vop_device *vop_dev =
container_of(dev_drv, struct vop_device, driver);
struct rk_lcdc_win *win = NULL;
- int i, ovl;
+ int i, ovl = 0;
u64 val;
int z_order_num = 0;
- int layer0_sel, layer1_sel, layer2_sel, layer3_sel;
+ int layer0_sel = 0, layer1_sel = 1, layer2_sel = 2, layer3_sel = 3;
if (swap == 0) {
for (i = 0; i < dev_drv->lcdc_win_num; i++) {
break;
case 6:
strcpy(fmt, "YCbCr444");
+ case 8:
+ strcpy(fmt, "YUYV422");
+ break;
+ case 9:
+ strcpy(fmt, "YUYV420");
+ break;
+ case 10:
+ strcpy(fmt, "UYVY422");
+ break;
+ case 11:
+ strcpy(fmt, "UYVY420");
break;
default:
strcpy(fmt, "invalid\n");
u32 fmt_id;
char format_w0[9] = "NULL";
char format_w1[9] = "NULL";
+ char format_w2_0[9] = "NULL";
+ char format_w2_1[9] = "NULL";
+ char format_w2_2[9] = "NULL";
+ char format_w2_3[9] = "NULL";
+ char format_w3_0[9] = "NULL";
+ char format_w3_1[9] = "NULL";
+ char format_w3_2[9] = "NULL";
+ char format_w3_3[9] = "NULL";
char dsp_buf[100];
u32 win_ctrl, zorder, vir_info, act_info, dsp_info, dsp_st;
u32 y_factor, uv_factor;
- u8 layer0_sel, layer1_sel;
- u8 w0_state, w1_state;
+ u8 layer0_sel, layer1_sel, layer2_sel, layer3_sel;
+ u8 w0_state, w1_state, w2_state, w3_state;
+ u8 w2_0_state, w2_1_state, w2_2_state, w2_3_state;
+ u8 w3_0_state, w3_1_state, w3_2_state, w3_3_state;
u32 w0_vir_y, w0_vir_uv, w0_act_x, w0_act_y, w0_dsp_x, w0_dsp_y;
u32 w0_st_x = h_pw_bp, w0_st_y = v_pw_bp;
u32 w0_y_h_fac, w0_y_v_fac, w0_uv_h_fac, w0_uv_v_fac;
u32 w1_y_h_fac, w1_y_v_fac, w1_uv_h_fac, w1_uv_v_fac;
+ u32 w2_0_vir_y, w2_1_vir_y, w2_2_vir_y, w2_3_vir_y;
+ u32 w2_0_dsp_x, w2_1_dsp_x, w2_2_dsp_x, w2_3_dsp_x;
+ u32 w2_0_dsp_y, w2_1_dsp_y, w2_2_dsp_y, w2_3_dsp_y;
+ u32 w2_0_st_x = h_pw_bp, w2_1_st_x = h_pw_bp;
+ u32 w2_2_st_x = h_pw_bp, w2_3_st_x = h_pw_bp;
+ u32 w2_0_st_y = v_pw_bp, w2_1_st_y = v_pw_bp;
+ u32 w2_2_st_y = v_pw_bp, w2_3_st_y = v_pw_bp;
+
+ u32 w3_0_vir_y, w3_1_vir_y, w3_2_vir_y, w3_3_vir_y;
+ u32 w3_0_dsp_x, w3_1_dsp_x, w3_2_dsp_x, w3_3_dsp_x;
+ u32 w3_0_dsp_y, w3_1_dsp_y, w3_2_dsp_y, w3_3_dsp_y;
+ u32 w3_0_st_x = h_pw_bp, w3_1_st_x = h_pw_bp;
+ u32 w3_2_st_x = h_pw_bp, w3_3_st_x = h_pw_bp;
+ u32 w3_0_st_y = v_pw_bp, w3_1_st_y = v_pw_bp;
+ u32 w3_2_st_y = v_pw_bp, w3_3_st_y = v_pw_bp;
u32 dclk_freq;
int size = 0;
zorder = vop_readl(vop_dev, DSP_CTRL1);
layer0_sel = (zorder & MASK(DSP_LAYER0_SEL)) >> 8;
layer1_sel = (zorder & MASK(DSP_LAYER1_SEL)) >> 10;
+ layer2_sel = (zorder & MASK(DSP_LAYER2_SEL)) >> 12;
+ layer3_sel = (zorder & MASK(DSP_LAYER3_SEL)) >> 14;
/* WIN0 */
win_ctrl = vop_readl(vop_dev, WIN0_CTRL0);
w0_state = win_ctrl & MASK(WIN0_EN);
fmt_id = (win_ctrl & MASK(WIN0_DATA_FMT)) >> 1;
+ fmt_id |= (win_ctrl & MASK(WIN0_YUYV)) >> 14; /* yuyv*/
vop_format_to_string(fmt_id, format_w0);
vir_info = vop_readl(vop_dev, WIN0_VIR);
act_info = vop_readl(vop_dev, WIN0_ACT_INFO);
win_ctrl = vop_readl(vop_dev, WIN1_CTRL0);
w1_state = win_ctrl & MASK(WIN1_EN);
fmt_id = (win_ctrl & MASK(WIN1_DATA_FMT)) >> 1;
+ fmt_id |= (win_ctrl & MASK(WIN1_YUYV)) >> 14; /* yuyv*/
vop_format_to_string(fmt_id, format_w1);
vir_info = vop_readl(vop_dev, WIN1_VIR);
act_info = vop_readl(vop_dev, WIN1_ACT_INFO);
w1_y_v_fac = (y_factor & MASK(WIN1_VS_FACTOR_YRGB)) >> 16;
w1_uv_h_fac = uv_factor & MASK(WIN1_HS_FACTOR_CBR);
w1_uv_v_fac = (uv_factor & MASK(WIN1_VS_FACTOR_CBR)) >> 16;
+
+ /*WIN2 */
+ win_ctrl = vop_readl(vop_dev, WIN2_CTRL0);
+ w2_state = win_ctrl & MASK(WIN2_EN);
+ w2_0_state = (win_ctrl & 0x10) >> 4;
+ w2_1_state = (win_ctrl & 0x100) >> 8;
+ w2_2_state = (win_ctrl & 0x1000) >> 12;
+ w2_3_state = (win_ctrl & 0x10000) >> 16;
+ vir_info = vop_readl(vop_dev, WIN2_VIR0_1);
+ w2_0_vir_y = vir_info & MASK(WIN2_VIR_STRIDE0);
+ w2_1_vir_y = (vir_info & MASK(WIN2_VIR_STRIDE1)) >> 16;
+ vir_info = vop_readl(vop_dev, WIN2_VIR2_3);
+ w2_2_vir_y = vir_info & MASK(WIN2_VIR_STRIDE2);
+ w2_3_vir_y = (vir_info & MASK(WIN2_VIR_STRIDE3)) >> 16;
+
+ fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT0)) >> 5;
+ vop_format_to_string(fmt_id, format_w2_0);
+ fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT1)) >> 9;
+ vop_format_to_string(fmt_id, format_w2_1);
+ fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT2)) >> 13;
+ vop_format_to_string(fmt_id, format_w2_2);
+ fmt_id = (win_ctrl & MASK(WIN2_DATA_FMT3)) >> 17;
+ vop_format_to_string(fmt_id, format_w2_3);
+
+ dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO0);
+ dsp_st = vop_readl(vop_dev, WIN2_DSP_ST0);
+ w2_0_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH0)) + 1;
+ w2_0_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT0)) >> 16) + 1;
+ if (w2_0_state) {
+ w2_0_st_x = dsp_st & MASK(WIN2_DSP_XST0);
+ w2_0_st_y = (dsp_st & MASK(WIN2_DSP_YST0)) >> 16;
+ }
+ dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO1);
+ dsp_st = vop_readl(vop_dev, WIN2_DSP_ST1);
+ w2_1_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH1)) + 1;
+ w2_1_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT1)) >> 16) + 1;
+ if (w2_1_state) {
+ w2_1_st_x = dsp_st & MASK(WIN2_DSP_XST1);
+ w2_1_st_y = (dsp_st & MASK(WIN2_DSP_YST1)) >> 16;
+ }
+ dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO2);
+ dsp_st = vop_readl(vop_dev, WIN2_DSP_ST2);
+ w2_2_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH2)) + 1;
+ w2_2_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT2)) >> 16) + 1;
+ if (w2_2_state) {
+ w2_2_st_x = dsp_st & MASK(WIN2_DSP_XST2);
+ w2_2_st_y = (dsp_st & MASK(WIN2_DSP_YST2)) >> 16;
+ }
+ dsp_info = vop_readl(vop_dev, WIN2_DSP_INFO3);
+ dsp_st = vop_readl(vop_dev, WIN2_DSP_ST3);
+ w2_3_dsp_x = (dsp_info & MASK(WIN2_DSP_WIDTH3)) + 1;
+ w2_3_dsp_y = ((dsp_info & MASK(WIN2_DSP_HEIGHT3)) >> 16) + 1;
+ if (w2_3_state) {
+ w2_3_st_x = dsp_st & MASK(WIN2_DSP_XST3);
+ w2_3_st_y = (dsp_st & MASK(WIN2_DSP_YST3)) >> 16;
+ }
+
+ /*WIN3 */
+ win_ctrl = vop_readl(vop_dev, WIN3_CTRL0);
+ w3_state = win_ctrl & MASK(WIN3_EN);
+ w3_0_state = (win_ctrl & 0x10) >> 4;
+ w3_1_state = (win_ctrl & 0x100) >> 8;
+ w3_2_state = (win_ctrl & 0x1000) >> 12;
+ w3_3_state = (win_ctrl & 0x10000) >> 16;
+ vir_info = vop_readl(vop_dev, WIN3_VIR0_1);
+ w3_0_vir_y = vir_info & MASK(WIN3_VIR_STRIDE0);
+ w3_1_vir_y = (vir_info & MASK(WIN3_VIR_STRIDE1)) >> 16;
+ vir_info = vop_readl(vop_dev, WIN3_VIR2_3);
+ w3_2_vir_y = vir_info & MASK(WIN3_VIR_STRIDE2);
+ w3_3_vir_y = (vir_info & MASK(WIN3_VIR_STRIDE3)) >> 16;
+
+ fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT0)) >> 5;
+ vop_format_to_string(fmt_id, format_w3_0);
+ fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT1)) >> 9;
+ vop_format_to_string(fmt_id, format_w3_1);
+ fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT2)) >> 13;
+ vop_format_to_string(fmt_id, format_w3_2);
+ fmt_id = (win_ctrl & MASK(WIN3_DATA_FMT3)) >> 17;
+ vop_format_to_string(fmt_id, format_w3_3);
+
+ dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO0);
+ dsp_st = vop_readl(vop_dev, WIN3_DSP_ST0);
+ w3_0_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH0)) + 1;
+ w3_0_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT0)) >> 16) + 1;
+ if (w3_0_state) {
+ w3_0_st_x = dsp_st & MASK(WIN3_DSP_XST0);
+ w3_0_st_y = (dsp_st & MASK(WIN3_DSP_YST0)) >> 16;
+ }
+ dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO1);
+ dsp_st = vop_readl(vop_dev, WIN3_DSP_ST1);
+ w3_1_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH1)) + 1;
+ w3_1_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT1)) >> 16) + 1;
+ if (w3_1_state) {
+ w3_1_st_x = dsp_st & MASK(WIN3_DSP_XST1);
+ w3_1_st_y = (dsp_st & MASK(WIN3_DSP_YST1)) >> 16;
+ }
+ dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO2);
+ dsp_st = vop_readl(vop_dev, WIN3_DSP_ST2);
+ w3_2_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH2)) + 1;
+ w3_2_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT2)) >> 16) + 1;
+ if (w3_2_state) {
+ w3_2_st_x = dsp_st & MASK(WIN3_DSP_XST2);
+ w3_2_st_y = (dsp_st & MASK(WIN3_DSP_YST2)) >> 16;
+ }
+ dsp_info = vop_readl(vop_dev, WIN3_DSP_INFO3);
+ dsp_st = vop_readl(vop_dev, WIN3_DSP_ST3);
+ w3_3_dsp_x = (dsp_info & MASK(WIN3_DSP_WIDTH3)) + 1;
+ w3_3_dsp_y = ((dsp_info & MASK(WIN3_DSP_HEIGHT3)) >> 16) + 1;
+ if (w3_3_state) {
+ w3_3_st_x = dsp_st & MASK(WIN3_DSP_XST3);
+ w3_3_st_y = (dsp_st & MASK(WIN3_DSP_YST3)) >> 16;
+ }
} else {
spin_unlock(&vop_dev->reg_lock);
return -EPERM;
}
spin_unlock(&vop_dev->reg_lock);
size += snprintf(dsp_buf, 80,
- "z-order:\n win[%d]\n win[%d]\n",
- layer1_sel, layer0_sel);
+ "z-order:\n win[%d]\n win[%d]\n win[%d]\n win[%d]\n",
+ layer3_sel, layer2_sel, layer1_sel, layer0_sel);
strcat(buf, dsp_buf);
memset(dsp_buf, 0, sizeof(dsp_buf));
/* win0 */
strcat(buf, dsp_buf);
memset(dsp_buf, 0, sizeof(dsp_buf));
+ /*win2*/
+ size += snprintf(dsp_buf, 80,
+ "win2:\n state:%d\n",
+ w2_state);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ /*area 0*/
+ size += snprintf(dsp_buf, 80,
+ " area0: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w2_0_state, format_w2_0, w2_0_dsp_x, w2_0_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w2_0_st_x - h_pw_bp, w2_0_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN2_MST0));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*area 1*/
+ size += snprintf(dsp_buf, 80,
+ " area1: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w2_1_state, format_w2_1, w2_1_dsp_x, w2_1_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w2_1_st_x - h_pw_bp, w2_1_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN2_MST1));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*area 2*/
+ size += snprintf(dsp_buf, 80,
+ " area2: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w2_2_state, format_w2_2, w2_2_dsp_x, w2_2_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w2_2_st_x - h_pw_bp, w2_2_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN2_MST2));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*area 3*/
+ size += snprintf(dsp_buf, 80,
+ " area3: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w2_3_state, format_w2_3, w2_3_dsp_x, w2_3_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w2_3_st_x - h_pw_bp, w2_3_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN2_MST3));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*win3*/
+ size += snprintf(dsp_buf, 80,
+ "win3:\n state:%d\n",
+ w3_state);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ /*area 0*/
+ size += snprintf(dsp_buf, 80,
+ " area0: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w3_0_state, format_w3_0, w3_0_dsp_x, w3_0_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w3_0_st_x - h_pw_bp, w3_0_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN3_MST0));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*area 1*/
+ size += snprintf(dsp_buf, 80,
+ " area1: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w3_1_state, format_w3_1, w3_1_dsp_x, w3_1_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w3_1_st_x - h_pw_bp, w3_1_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN3_MST1));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*area 2*/
+ size += snprintf(dsp_buf, 80,
+ " area2: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w3_2_state, format_w3_2, w3_2_dsp_x, w3_2_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w3_2_st_x - h_pw_bp, w3_2_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN3_MST2));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
+ /*area 3*/
+ size += snprintf(dsp_buf, 80,
+ " area3: state:%d, fmt:%7s, dsp_x:%4d, dsp_y:%4d,",
+ w3_3_state, format_w3_3, w3_3_dsp_x, w3_3_dsp_y);
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+ size += snprintf(dsp_buf, 80,
+ " x_st:%4d, y_st:%4d, y_addr:0x%08x\n",
+ w3_3_st_x - h_pw_bp, w3_3_st_y - v_pw_bp,
+ vop_readl(vop_dev, WIN3_MST3));
+ strcat(buf, dsp_buf);
+ memset(dsp_buf, 0, sizeof(dsp_buf));
+
return size;
}
vop_msk_reg(vop_dev, SYS_CTRL, V_VOP_STANDBY_EN(vop_dev->standby));
for (i = 0; i < dev_drv->lcdc_win_num; i++) {
win = dev_drv->win[i];
+ vop_alpha_cfg(dev_drv, i);
fbdc_en |= win->area[0].fbdc_en;
+ vop_dev->atv_layer_cnt &= ~(1 << win->id);
+ vop_dev->atv_layer_cnt |= (win->state << win->id);
if ((win->state == 0) && (win->last_state == 1)) {
switch (win->id) {
case 0:
if (enable)
enable_irq(vop_dev->irq);
else
- disable_irq(vop_dev->irq);
+ disable_irq_nosync(vop_dev->irq);
return 0;
}
{
struct vop_device *vop_dev =
container_of(dev_drv, struct vop_device, driver);
- u32 val;
+ u32 val = 0;
spin_lock(&vop_dev->reg_lock);
if (vop_dev->clk_on) {
{
struct vop_device *vop_dev =
container_of(dev_drv, struct vop_device, driver);
- u64 val;
+ u64 val = 0;
spin_lock(&vop_dev->reg_lock);
if (vop_dev->clk_on) {
{
struct vop_device *vop_dev =
container_of(dev_drv, struct vop_device, driver);
- u64 val;
+ u64 val = 0;
spin_lock(&vop_dev->reg_lock);
if (vop_dev->clk_on) {
if (intr_status & INTR_FS) {
timestamp = ktime_get();
- if (vop_dev->wb_on) {
+ if (vop_dev->driver.wb_data.state) {
u32 wb_status;
spin_lock_irqsave(&vop_dev->irq_lock, flags);
wb_status = vop_read_bit(vop_dev, WB_CTRL0, V_WB_EN(0));
+
if (wb_status)
- vop_set_bit(vop_dev, WB_CTRL0, V_WB_EN(0));
+ vop_clr_bit(vop_dev, WB_CTRL0, V_WB_EN(0));
vop_cfg_done(vop_dev);
vop_dev->driver.wb_data.state = 0;
platform_set_drvdata(pdev, vop_dev);
vop_dev->dev = dev;
vop_parse_dt(vop_dev);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ /* enable power domain */
+ pm_runtime_enable(dev);
+#endif
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
vop_dev->reg_phy_base = res->start;
vop_dev->len = resource_size(res);
- vop_dev->regs = devm_ioremap_resource(dev, res);
+ vop_dev->regs = devm_ioremap(&pdev->dev, res->start,
+ resource_size(res));
if (IS_ERR(vop_dev->regs))
return PTR_ERR(vop_dev->regs);
vop_dev->irq, ret);
return ret;
}
- if (dev_drv->iommu_enabled)
- strcpy(dev_drv->mmu_dts_name, VOP_IOMMU_COMPATIBLE_NAME);
+ if (dev_drv->iommu_enabled) {
+ if (VOP_CHIP(vop_dev) == VOP_RK322X) {
+ strcpy(dev_drv->mmu_dts_name,
+ VOP_IOMMU_COMPATIBLE_NAME);
+ } else {
+ if (vop_dev->id == 0)
+ strcpy(dev_drv->mmu_dts_name,
+ VOPB_IOMMU_COMPATIBLE_NAME);
+ else
+ strcpy(dev_drv->mmu_dts_name,
+ VOPL_IOMMU_COMPATIBLE_NAME);
+ }
+ }
+ if (VOP_CHIP(vop_dev) == VOP_RK3399)
+ dev_drv->property.feature |= SUPPORT_WRITE_BACK | SUPPORT_AFBDC;
+ dev_drv->property.feature |= SUPPORT_VOP_IDENTIFY |
+ SUPPORT_YUV420_OUTPUT;
+ dev_drv->property.max_output_x = 4096;
+ dev_drv->property.max_output_y = 2160;
+
+ if ((VOP_CHIP(vop_dev) == VOP_RK3399) && (vop_dev->id == 1)) {
+ vop_dev->data->win[1].property.feature &= ~SUPPORT_HW_EXIST;
+ vop_dev->data->win[3].property.feature &= ~SUPPORT_HW_EXIST;
+ }
+
ret = rk_fb_register(dev_drv, vop_dev->data->win, vop_dev->id);
if (ret < 0) {
dev_err(dev, "register fb for lcdc%d failed!\n", vop_dev->id);
vop_deint(vop_dev);
vop_clk_disable(vop_dev);
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
+ pm_runtime_disable(vop_dev->dev);
+#endif
rk_disp_pwr_disable(dev_drv);
}