1 /* 2 * (C) Copyright 2008-2017 Fuzhou Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <config.h> 8 #include <common.h> 9 #include <errno.h> 10 #include <malloc.h> 11 #include <fdtdec.h> 12 #include <fdt_support.h> 13 #include <asm/unaligned.h> 14 #include <asm/io.h> 15 #include <linux/list.h> 16 #include <linux/media-bus-format.h> 17 #include <clk.h> 18 #include <asm/arch/clock.h> 19 #include <linux/err.h> 20 #include <dm/device.h> 21 #include <dm/read.h> 22 23 #include "rockchip_display.h" 24 #include "rockchip_crtc.h" 25 #include "rockchip_connector.h" 26 #include "rockchip_vop.h" 27 28 static inline int us_to_vertical_line(struct drm_display_mode *mode, int us) 29 { 30 return us * mode->clock / mode->htotal / 1000; 31 } 32 33 static int to_vop_csc_mode(int csc_mode) 34 { 35 switch (csc_mode) { 36 case V4L2_COLORSPACE_SMPTE170M: 37 return CSC_BT601L; 38 case V4L2_COLORSPACE_REC709: 39 case V4L2_COLORSPACE_DEFAULT: 40 return CSC_BT709L; 41 case V4L2_COLORSPACE_JPEG: 42 return CSC_BT601F; 43 case V4L2_COLORSPACE_BT2020: 44 return CSC_BT2020; 45 default: 46 return CSC_BT709L; 47 } 48 } 49 50 static bool is_yuv_output(uint32_t bus_format) 51 { 52 switch (bus_format) { 53 case MEDIA_BUS_FMT_YUV8_1X24: 54 case MEDIA_BUS_FMT_YUV10_1X30: 55 case MEDIA_BUS_FMT_UYYVYY8_0_5X24: 56 case MEDIA_BUS_FMT_UYYVYY10_0_5X30: 57 return true; 58 default: 59 return false; 60 } 61 } 62 63 static bool is_uv_swap(uint32_t bus_format, uint32_t output_mode) 64 { 65 /* 66 * FIXME: 67 * 68 * There is no media type for YUV444 output, 69 * so when out_mode is AAAA or P888, assume output is YUV444 on 70 * yuv format. 71 * 72 * From H/W testing, YUV444 mode need a rb swap. 73 */ 74 if ((bus_format == MEDIA_BUS_FMT_YUV8_1X24 || 75 bus_format == MEDIA_BUS_FMT_YUV10_1X30) && 76 (output_mode == ROCKCHIP_OUT_MODE_AAAA || 77 output_mode == ROCKCHIP_OUT_MODE_P888)) 78 return true; 79 else 80 return false; 81 } 82 83 static int rockchip_vop_init_gamma(struct vop *vop, struct display_state *state) 84 { 85 struct crtc_state *crtc_state = &state->crtc_state; 86 struct connector_state *conn_state = &state->conn_state; 87 u32 *lut = conn_state->gamma.lut; 88 fdt_size_t lut_size; 89 int i, lut_len; 90 u32 *lut_regs; 91 92 if (!conn_state->gamma.lut) 93 return 0; 94 95 i = dev_read_stringlist_search(crtc_state->dev, "reg-names", "gamma_lut"); 96 if (i < 0) { 97 printf("Warning: vop not support gamma\n"); 98 return 0; 99 } 100 lut_regs = (u32 *)dev_read_addr_size(crtc_state->dev, "reg", &lut_size); 101 if (lut_regs == (u32 *)FDT_ADDR_T_NONE) { 102 printf("failed to get gamma lut register\n"); 103 return 0; 104 } 105 lut_len = lut_size / 4; 106 if (lut_len != 256 && lut_len != 1024) { 107 printf("Warning: unsupport gamma lut table[%d]\n", lut_len); 108 return 0; 109 } 110 111 if (conn_state->gamma.size != lut_len) { 112 int size = conn_state->gamma.size; 113 u32 j, r, g, b, color; 114 115 for (i = 0; i < lut_len; i++) { 116 j = i * size / lut_len; 117 r = lut[j] / size / size * lut_len / size; 118 g = lut[j] / size % size * lut_len / size; 119 b = lut[j] % size * lut_len / size; 120 color = r * lut_len * lut_len + g * lut_len + b; 121 122 writel(color, lut_regs + (i << 2)); 123 } 124 } else { 125 for (i = 0; i < lut_len; i++) 126 writel(lut[i], lut_regs + (i << 2)); 127 } 128 129 VOP_CTRL_SET(vop, dsp_lut_en, 1); 130 VOP_CTRL_SET(vop, update_gamma_lut, 1); 131 132 return 0; 133 } 134 135 static void vop_post_config(struct display_state *state, struct vop *vop) 136 { 137 struct connector_state *conn_state = &state->conn_state; 138 struct drm_display_mode *mode = &conn_state->mode; 139 u16 vtotal = mode->crtc_vtotal; 140 u16 hact_st = mode->crtc_htotal - mode->crtc_hsync_start; 141 u16 vact_st = mode->crtc_vtotal - mode->crtc_vsync_start; 142 u16 hdisplay = mode->crtc_hdisplay; 143 u16 vdisplay = mode->crtc_vdisplay; 144 u16 hsize = hdisplay * (conn_state->overscan.left_margin + conn_state->overscan.right_margin) / 200; 145 u16 vsize = vdisplay * (conn_state->overscan.top_margin + conn_state->overscan.bottom_margin) / 200; 146 u16 hact_end, vact_end; 147 u32 val; 148 149 if (mode->flags & DRM_MODE_FLAG_INTERLACE) 150 vsize = round_down(vsize, 2); 151 152 hact_st += hdisplay * (100 - conn_state->overscan.left_margin) / 200; 153 hact_end = hact_st + hsize; 154 val = hact_st << 16; 155 val |= hact_end; 156 157 VOP_CTRL_SET(vop, hpost_st_end, val); 158 vact_st += vdisplay * (100 - conn_state->overscan.top_margin) / 200; 159 vact_end = vact_st + vsize; 160 val = vact_st << 16; 161 val |= vact_end; 162 VOP_CTRL_SET(vop, vpost_st_end, val); 163 val = scl_cal_scale2(vdisplay, vsize) << 16; 164 val |= scl_cal_scale2(hdisplay, hsize); 165 VOP_CTRL_SET(vop, post_scl_factor, val); 166 #define POST_HORIZONTAL_SCALEDOWN_EN(x) ((x) << 0) 167 #define POST_VERTICAL_SCALEDOWN_EN(x) ((x) << 1) 168 VOP_CTRL_SET(vop, post_scl_ctrl, 169 POST_HORIZONTAL_SCALEDOWN_EN(hdisplay != hsize) | 170 POST_VERTICAL_SCALEDOWN_EN(vdisplay != vsize)); 171 if (mode->flags & DRM_MODE_FLAG_INTERLACE) { 172 u16 vact_st_f1 = vtotal + vact_st + 1; 173 u16 vact_end_f1 = vact_st_f1 + vsize; 174 175 val = vact_st_f1 << 16 | vact_end_f1; 176 VOP_CTRL_SET(vop, vpost_st_end_f1, val); 177 } 178 } 179 180 static int rockchip_vop_init(struct display_state *state) 181 { 182 struct crtc_state *crtc_state = &state->crtc_state; 183 struct connector_state *conn_state = &state->conn_state; 184 struct drm_display_mode *mode = &conn_state->mode; 185 const struct rockchip_crtc *crtc = crtc_state->crtc; 186 const struct vop_data *vop_data = crtc->data; 187 struct vop *vop; 188 u16 hsync_len = mode->crtc_hsync_end - mode->crtc_hsync_start; 189 u16 hdisplay = mode->crtc_hdisplay; 190 u16 htotal = mode->crtc_htotal; 191 u16 hact_st = mode->crtc_htotal - mode->crtc_hsync_start; 192 u16 hact_end = hact_st + hdisplay; 193 u16 vdisplay = mode->crtc_vdisplay; 194 u16 vtotal = mode->crtc_vtotal; 195 u16 vsync_len = mode->crtc_vsync_end - mode->crtc_vsync_start; 196 u16 vact_st = mode->crtc_vtotal - mode->crtc_vsync_start; 197 u16 vact_end = vact_st + vdisplay; 198 struct clk dclk, aclk; 199 u32 val, act_end; 200 int ret; 201 bool yuv_overlay = false, post_r2y_en = false, post_y2r_en = false; 202 u16 post_csc_mode; 203 204 vop = malloc(sizeof(*vop)); 205 if (!vop) 206 return -ENOMEM; 207 memset(vop, 0, sizeof(*vop)); 208 209 crtc_state->private = vop; 210 vop->regs = dev_read_addr_ptr(crtc_state->dev); 211 vop->regsbak = malloc(vop_data->reg_len); 212 vop->win = vop_data->win; 213 vop->win_offset = vop_data->win_offset; 214 vop->ctrl = vop_data->ctrl; 215 vop->line_flag = vop_data->line_flag; 216 vop->version = vop_data->version; 217 vop->max_output = vop_data->max_output; 218 219 /* 220 * TODO: 221 * Set Dclk pll parent 222 */ 223 224 ret = clk_get_by_name(crtc_state->dev, "dclk_vop", &dclk); 225 if (!ret) 226 ret = clk_set_rate(&dclk, mode->clock * 1000); 227 if (IS_ERR_VALUE(ret)) { 228 printf("%s: Failed to set dclk: ret=%d\n", __func__, ret); 229 return ret; 230 } 231 232 ret = clk_get_by_name(crtc_state->dev, "aclk_vop", &aclk); 233 if (!ret) 234 ret = clk_set_rate(&aclk, 400 * 1000 * 1000); 235 if (IS_ERR_VALUE(ret)) 236 printf("%s: Failed to set aclk: ret=%d\n", __func__, ret); 237 238 memcpy(vop->regsbak, vop->regs, vop_data->reg_len); 239 240 rockchip_vop_init_gamma(vop, state); 241 242 VOP_CTRL_SET(vop, global_regdone_en, 1); 243 VOP_CTRL_SET(vop, axi_outstanding_max_num, 30); 244 VOP_CTRL_SET(vop, axi_max_outstanding_en, 1); 245 VOP_CTRL_SET(vop, reg_done_frm, 1); 246 VOP_CTRL_SET(vop, win_gate[0], 1); 247 VOP_CTRL_SET(vop, win_gate[1], 1); 248 VOP_CTRL_SET(vop, win_channel[0], 0x12); 249 VOP_CTRL_SET(vop, win_channel[1], 0x34); 250 VOP_CTRL_SET(vop, win_channel[2], 0x56); 251 VOP_CTRL_SET(vop, dsp_blank, 0); 252 253 val = 0x8; 254 val |= (mode->flags & DRM_MODE_FLAG_NHSYNC) ? 0 : 1; 255 val |= (mode->flags & DRM_MODE_FLAG_NVSYNC) ? 0 : (1 << 1); 256 VOP_CTRL_SET(vop, pin_pol, val); 257 258 switch (conn_state->type) { 259 case DRM_MODE_CONNECTOR_LVDS: 260 VOP_CTRL_SET(vop, rgb_en, 1); 261 VOP_CTRL_SET(vop, rgb_pin_pol, val); 262 break; 263 case DRM_MODE_CONNECTOR_eDP: 264 VOP_CTRL_SET(vop, edp_en, 1); 265 VOP_CTRL_SET(vop, edp_pin_pol, val); 266 break; 267 case DRM_MODE_CONNECTOR_HDMIA: 268 VOP_CTRL_SET(vop, hdmi_en, 1); 269 VOP_CTRL_SET(vop, hdmi_pin_pol, val); 270 break; 271 case DRM_MODE_CONNECTOR_DSI: 272 VOP_CTRL_SET(vop, mipi_en, 1); 273 VOP_CTRL_SET(vop, mipi_pin_pol, val); 274 VOP_CTRL_SET(vop, mipi_dual_channel_en, 275 !!(conn_state->output_type & ROCKCHIP_OUTPUT_DSI_DUAL_CHANNEL)); 276 VOP_CTRL_SET(vop, data01_swap, 277 !!(conn_state->output_type & ROCKCHIP_OUTPUT_DSI_DUAL_LINK)); 278 break; 279 case DRM_MODE_CONNECTOR_TV: 280 if (vdisplay == CVBS_PAL_VDISPLAY) 281 VOP_CTRL_SET(vop, tve_sw_mode, 1); 282 else 283 VOP_CTRL_SET(vop, tve_sw_mode, 0); 284 VOP_CTRL_SET(vop, tve_dclk_pol, 1); 285 VOP_CTRL_SET(vop, tve_dclk_en, 1); 286 /* use the same pol reg with hdmi */ 287 VOP_CTRL_SET(vop, hdmi_pin_pol, val); 288 VOP_CTRL_SET(vop, sw_genlock, 1); 289 VOP_CTRL_SET(vop, sw_uv_offset_en, 1); 290 VOP_CTRL_SET(vop, dither_up, 1); 291 break; 292 default: 293 printf("unsupport connector_type[%d]\n", conn_state->type); 294 } 295 296 if (conn_state->output_mode == ROCKCHIP_OUT_MODE_AAAA && 297 !(vop_data->feature & VOP_FEATURE_OUTPUT_10BIT)) 298 conn_state->output_mode = ROCKCHIP_OUT_MODE_P888; 299 300 switch (conn_state->bus_format) { 301 case MEDIA_BUS_FMT_RGB565_1X16: 302 val = DITHER_DOWN_EN(1) | DITHER_DOWN_MODE(RGB888_TO_RGB565); 303 break; 304 case MEDIA_BUS_FMT_RGB666_1X18: 305 case MEDIA_BUS_FMT_RGB666_1X24_CPADHI: 306 val = DITHER_DOWN_EN(1) | DITHER_DOWN_MODE(RGB888_TO_RGB666); 307 break; 308 case MEDIA_BUS_FMT_YUV8_1X24: 309 case MEDIA_BUS_FMT_UYYVYY8_0_5X24: 310 val = DITHER_DOWN_EN(0) | PRE_DITHER_DOWN_EN(1); 311 break; 312 case MEDIA_BUS_FMT_YUV10_1X30: 313 case MEDIA_BUS_FMT_UYYVYY10_0_5X30: 314 val = DITHER_DOWN_EN(0) | PRE_DITHER_DOWN_EN(0); 315 break; 316 case MEDIA_BUS_FMT_RGB888_1X24: 317 default: 318 val = DITHER_DOWN_EN(0) | PRE_DITHER_DOWN_EN(0); 319 break; 320 } 321 if (conn_state->output_mode == ROCKCHIP_OUT_MODE_AAAA) 322 val |= PRE_DITHER_DOWN_EN(0); 323 else 324 val |= PRE_DITHER_DOWN_EN(1); 325 val |= DITHER_DOWN_MODE_SEL(DITHER_DOWN_ALLEGRO); 326 VOP_CTRL_SET(vop, dither_down, val); 327 328 VOP_CTRL_SET(vop, dclk_ddr, 329 conn_state->output_mode == ROCKCHIP_OUT_MODE_YUV420 ? 1 : 0); 330 VOP_CTRL_SET(vop, hdmi_dclk_out_en, 331 conn_state->output_mode == ROCKCHIP_OUT_MODE_YUV420 ? 1 : 0); 332 333 if (is_uv_swap(conn_state->bus_format, conn_state->output_mode)) 334 VOP_CTRL_SET(vop, dsp_data_swap, DSP_RB_SWAP); 335 else 336 VOP_CTRL_SET(vop, dsp_data_swap, 0); 337 338 VOP_CTRL_SET(vop, out_mode, conn_state->output_mode); 339 340 if (VOP_CTRL_SUPPORT(vop, overlay_mode)) { 341 yuv_overlay = is_yuv_output(conn_state->bus_format); 342 VOP_CTRL_SET(vop, overlay_mode, yuv_overlay); 343 } 344 /* 345 * todo: r2y for win csc 346 */ 347 VOP_CTRL_SET(vop, dsp_out_yuv, is_yuv_output(conn_state->bus_format)); 348 349 if (yuv_overlay) { 350 if (!is_yuv_output(conn_state->bus_format)) 351 post_y2r_en = true; 352 } else { 353 if (is_yuv_output(conn_state->bus_format)) 354 post_r2y_en = true; 355 } 356 357 post_csc_mode = to_vop_csc_mode(conn_state->color_space); 358 VOP_CTRL_SET(vop, bcsh_r2y_en, post_r2y_en); 359 VOP_CTRL_SET(vop, bcsh_y2r_en, post_y2r_en); 360 VOP_CTRL_SET(vop, bcsh_r2y_csc_mode, post_csc_mode); 361 VOP_CTRL_SET(vop, bcsh_y2r_csc_mode, post_csc_mode); 362 363 /* 364 * Background color is 10bit depth if vop version >= 3.5 365 */ 366 if (!is_yuv_output(conn_state->bus_format)) 367 val = 0; 368 else if (VOP_MAJOR(vop->version) == 3 && 369 VOP_MINOR(vop->version) >= 5) 370 val = 0x20010200; 371 else 372 val = 0x801080; 373 VOP_CTRL_SET(vop, dsp_background, val); 374 375 VOP_CTRL_SET(vop, htotal_pw, (htotal << 16) | hsync_len); 376 val = hact_st << 16; 377 val |= hact_end; 378 VOP_CTRL_SET(vop, hact_st_end, val); 379 val = vact_st << 16; 380 val |= vact_end; 381 VOP_CTRL_SET(vop, vact_st_end, val); 382 if (mode->flags & DRM_MODE_FLAG_INTERLACE) { 383 u16 vact_st_f1 = vtotal + vact_st + 1; 384 u16 vact_end_f1 = vact_st_f1 + vdisplay; 385 386 val = vact_st_f1 << 16 | vact_end_f1; 387 VOP_CTRL_SET(vop, vact_st_end_f1, val); 388 389 val = vtotal << 16 | (vtotal + vsync_len); 390 VOP_CTRL_SET(vop, vs_st_end_f1, val); 391 VOP_CTRL_SET(vop, dsp_interlace, 1); 392 VOP_CTRL_SET(vop, p2i_en, 1); 393 vtotal += vtotal + 1; 394 act_end = vact_end_f1; 395 } else { 396 VOP_CTRL_SET(vop, dsp_interlace, 0); 397 VOP_CTRL_SET(vop, p2i_en, 0); 398 act_end = vact_end; 399 } 400 VOP_CTRL_SET(vop, vtotal_pw, (vtotal << 16) | vsync_len); 401 vop_post_config(state, vop); 402 VOP_CTRL_SET(vop, core_dclk_div, 403 !!(mode->flags & DRM_MODE_FLAG_DBLCLK)); 404 405 VOP_CTRL_SET(vop, standby, 1); 406 VOP_LINE_FLAG_SET(vop, line_flag_num[0], act_end - 3); 407 VOP_LINE_FLAG_SET(vop, line_flag_num[1], 408 act_end - us_to_vertical_line(mode, 1000)); 409 vop_cfg_done(vop); 410 411 return 0; 412 } 413 414 static uint16_t scl_vop_cal_scale(enum scale_mode mode, uint32_t src, 415 uint32_t dst, bool is_horizontal, 416 int vsu_mode, int *vskiplines) 417 { 418 uint16_t val = 1 << SCL_FT_DEFAULT_FIXPOINT_SHIFT; 419 420 if (is_horizontal) { 421 if (mode == SCALE_UP) 422 val = GET_SCL_FT_BIC(src, dst); 423 else if (mode == SCALE_DOWN) 424 val = GET_SCL_FT_BILI_DN(src, dst); 425 } else { 426 if (mode == SCALE_UP) { 427 if (vsu_mode == SCALE_UP_BIL) 428 val = GET_SCL_FT_BILI_UP(src, dst); 429 else 430 val = GET_SCL_FT_BIC(src, dst); 431 } else if (mode == SCALE_DOWN) { 432 if (vskiplines) { 433 *vskiplines = scl_get_vskiplines(src, dst); 434 val = scl_get_bili_dn_vskip(src, dst, 435 *vskiplines); 436 } else { 437 val = GET_SCL_FT_BILI_DN(src, dst); 438 } 439 } 440 } 441 442 return val; 443 } 444 445 static void scl_vop_cal_scl_fac(struct vop *vop, 446 uint32_t src_w, uint32_t src_h, uint32_t dst_w, 447 uint32_t dst_h, uint32_t pixel_format) 448 { 449 uint16_t yrgb_hor_scl_mode, yrgb_ver_scl_mode; 450 uint16_t cbcr_hor_scl_mode = SCALE_NONE; 451 uint16_t cbcr_ver_scl_mode = SCALE_NONE; 452 int hsub = drm_format_horz_chroma_subsampling(pixel_format); 453 int vsub = drm_format_vert_chroma_subsampling(pixel_format); 454 bool is_yuv = false; 455 uint16_t cbcr_src_w = src_w / hsub; 456 uint16_t cbcr_src_h = src_h / vsub; 457 uint16_t vsu_mode; 458 uint16_t lb_mode; 459 uint32_t val; 460 int vskiplines = 0; 461 462 if (!vop->win->scl) 463 return; 464 465 if (dst_w > vop->max_output.width) { 466 printf("Maximum destination width %d exceeded\n", 467 vop->max_output.width); 468 return; 469 } 470 471 if (!vop->win->scl->ext) { 472 VOP_SCL_SET(vop, scale_yrgb_x, 473 scl_cal_scale2(src_w, dst_w)); 474 VOP_SCL_SET(vop, scale_yrgb_y, 475 scl_cal_scale2(src_h, dst_h)); 476 if (is_yuv) { 477 VOP_SCL_SET(vop, scale_cbcr_x, 478 scl_cal_scale2(src_w, dst_w)); 479 VOP_SCL_SET(vop, scale_cbcr_y, 480 scl_cal_scale2(src_h, dst_h)); 481 } 482 return; 483 } 484 485 yrgb_hor_scl_mode = scl_get_scl_mode(src_w, dst_w); 486 yrgb_ver_scl_mode = scl_get_scl_mode(src_h, dst_h); 487 488 if (is_yuv) { 489 cbcr_hor_scl_mode = scl_get_scl_mode(cbcr_src_w, dst_w); 490 cbcr_ver_scl_mode = scl_get_scl_mode(cbcr_src_h, dst_h); 491 if (cbcr_hor_scl_mode == SCALE_DOWN) 492 lb_mode = scl_vop_cal_lb_mode(dst_w, true); 493 else 494 lb_mode = scl_vop_cal_lb_mode(cbcr_src_w, true); 495 } else { 496 if (yrgb_hor_scl_mode == SCALE_DOWN) 497 lb_mode = scl_vop_cal_lb_mode(dst_w, false); 498 else 499 lb_mode = scl_vop_cal_lb_mode(src_w, false); 500 } 501 502 VOP_SCL_SET_EXT(vop, lb_mode, lb_mode); 503 if (lb_mode == LB_RGB_3840X2) { 504 if (yrgb_ver_scl_mode != SCALE_NONE) { 505 printf("ERROR : not allow yrgb ver scale\n"); 506 return; 507 } 508 if (cbcr_ver_scl_mode != SCALE_NONE) { 509 printf("ERROR : not allow cbcr ver scale\n"); 510 return; 511 } 512 vsu_mode = SCALE_UP_BIL; 513 } else if (lb_mode == LB_RGB_2560X4) { 514 vsu_mode = SCALE_UP_BIL; 515 } else { 516 vsu_mode = SCALE_UP_BIC; 517 } 518 519 val = scl_vop_cal_scale(yrgb_hor_scl_mode, src_w, dst_w, 520 true, 0, NULL); 521 VOP_SCL_SET(vop, scale_yrgb_x, val); 522 val = scl_vop_cal_scale(yrgb_ver_scl_mode, src_h, dst_h, 523 false, vsu_mode, &vskiplines); 524 VOP_SCL_SET(vop, scale_yrgb_y, val); 525 526 VOP_SCL_SET_EXT(vop, vsd_yrgb_gt4, vskiplines == 4); 527 VOP_SCL_SET_EXT(vop, vsd_yrgb_gt2, vskiplines == 2); 528 529 VOP_SCL_SET_EXT(vop, yrgb_hor_scl_mode, yrgb_hor_scl_mode); 530 VOP_SCL_SET_EXT(vop, yrgb_ver_scl_mode, yrgb_ver_scl_mode); 531 VOP_SCL_SET_EXT(vop, yrgb_hsd_mode, SCALE_DOWN_BIL); 532 VOP_SCL_SET_EXT(vop, yrgb_vsd_mode, SCALE_DOWN_BIL); 533 VOP_SCL_SET_EXT(vop, yrgb_vsu_mode, vsu_mode); 534 if (is_yuv) { 535 val = scl_vop_cal_scale(cbcr_hor_scl_mode, cbcr_src_w, 536 dst_w, true, 0, NULL); 537 VOP_SCL_SET(vop, scale_cbcr_x, val); 538 val = scl_vop_cal_scale(cbcr_ver_scl_mode, cbcr_src_h, 539 dst_h, false, vsu_mode, &vskiplines); 540 VOP_SCL_SET(vop, scale_cbcr_y, val); 541 542 VOP_SCL_SET_EXT(vop, vsd_cbcr_gt4, vskiplines == 4); 543 VOP_SCL_SET_EXT(vop, vsd_cbcr_gt2, vskiplines == 2); 544 VOP_SCL_SET_EXT(vop, cbcr_hor_scl_mode, cbcr_hor_scl_mode); 545 VOP_SCL_SET_EXT(vop, cbcr_ver_scl_mode, cbcr_ver_scl_mode); 546 VOP_SCL_SET_EXT(vop, cbcr_hsd_mode, SCALE_DOWN_BIL); 547 VOP_SCL_SET_EXT(vop, cbcr_vsd_mode, SCALE_DOWN_BIL); 548 VOP_SCL_SET_EXT(vop, cbcr_vsu_mode, vsu_mode); 549 } 550 } 551 552 static int rockchip_vop_set_plane(struct display_state *state) 553 { 554 struct crtc_state *crtc_state = &state->crtc_state; 555 struct connector_state *conn_state = &state->conn_state; 556 struct drm_display_mode *mode = &conn_state->mode; 557 u32 act_info, dsp_info, dsp_st, dsp_stx, dsp_sty; 558 struct vop *vop = crtc_state->private; 559 int src_w = crtc_state->src_w; 560 int src_h = crtc_state->src_h; 561 int crtc_x = crtc_state->crtc_x; 562 int crtc_y = crtc_state->crtc_y; 563 int crtc_w = crtc_state->crtc_w; 564 int crtc_h = crtc_state->crtc_h; 565 int xvir = crtc_state->xvir; 566 567 act_info = (src_h - 1) << 16; 568 act_info |= (src_w - 1) & 0xffff; 569 570 dsp_info = (crtc_h - 1) << 16; 571 dsp_info |= (crtc_w - 1) & 0xffff; 572 573 dsp_stx = crtc_x + mode->htotal - mode->hsync_start; 574 dsp_sty = crtc_y + mode->vtotal - mode->vsync_start; 575 dsp_st = dsp_sty << 16 | (dsp_stx & 0xffff); 576 577 if (crtc_state->ymirror) { 578 if (VOP_WIN_SUPPORT(vop, vop->win, ymirror)) 579 crtc_state->dma_addr += (src_h - 1) * xvir * 4; 580 else 581 crtc_state->ymirror = 0; 582 } 583 VOP_WIN_SET(vop, ymirror, crtc_state->ymirror); 584 VOP_WIN_SET(vop, format, crtc_state->format); 585 VOP_WIN_SET(vop, yrgb_vir, xvir); 586 VOP_WIN_SET(vop, yrgb_mst, crtc_state->dma_addr); 587 588 scl_vop_cal_scl_fac(vop, src_w, src_h, crtc_w, crtc_h, 589 crtc_state->format); 590 591 VOP_WIN_SET(vop, act_info, act_info); 592 VOP_WIN_SET(vop, dsp_info, dsp_info); 593 VOP_WIN_SET(vop, dsp_st, dsp_st); 594 VOP_WIN_SET(vop, rb_swap, crtc_state->rb_swap); 595 596 VOP_WIN_SET(vop, src_alpha_ctl, 0); 597 598 VOP_WIN_SET(vop, enable, 1); 599 vop_cfg_done(vop); 600 601 return 0; 602 } 603 604 static int rockchip_vop_prepare(struct display_state *state) 605 { 606 return 0; 607 } 608 609 static int rockchip_vop_enable(struct display_state *state) 610 { 611 struct crtc_state *crtc_state = &state->crtc_state; 612 struct vop *vop = crtc_state->private; 613 614 VOP_CTRL_SET(vop, standby, 0); 615 vop_cfg_done(vop); 616 617 return 0; 618 } 619 620 static int rockchip_vop_disable(struct display_state *state) 621 { 622 struct crtc_state *crtc_state = &state->crtc_state; 623 struct vop *vop = crtc_state->private; 624 625 VOP_CTRL_SET(vop, standby, 1); 626 vop_cfg_done(vop); 627 return 0; 628 } 629 630 static int rockchip_vop_fixup_dts(struct display_state *state, void *blob) 631 { 632 #if 0 633 struct crtc_state *crtc_state = &state->crtc_state; 634 struct panel_state *pstate = &state->panel_state; 635 uint32_t phandle; 636 char path[100]; 637 int ret, dsp_lut_node; 638 639 if (!ofnode_valid(pstate->dsp_lut_node)) 640 return 0; 641 ret = fdt_get_path(state->blob, pstate->dsp_lut_node, path, sizeof(path)); 642 if (ret < 0) { 643 printf("failed to get dsp_lut path[%s], ret=%d\n", 644 path, ret); 645 return ret; 646 } 647 648 dsp_lut_node = fdt_path_offset(blob, path); 649 phandle = fdt_get_phandle(blob, dsp_lut_node); 650 if (!phandle) { 651 phandle = fdt_alloc_phandle(blob); 652 if (!phandle) { 653 printf("failed to alloc phandle\n"); 654 return -ENOMEM; 655 } 656 657 fdt_set_phandle(blob, dsp_lut_node, phandle); 658 } 659 660 ret = fdt_get_path(state->blob, crtc_state->node, path, sizeof(path)); 661 if (ret < 0) { 662 printf("failed to get route path[%s], ret=%d\n", 663 path, ret); 664 return ret; 665 } 666 667 do_fixup_by_path_u32(blob, path, "dsp-lut", phandle, 1); 668 #endif 669 return 0; 670 } 671 672 const struct rockchip_crtc_funcs rockchip_vop_funcs = { 673 .init = rockchip_vop_init, 674 .set_plane = rockchip_vop_set_plane, 675 .prepare = rockchip_vop_prepare, 676 .enable = rockchip_vop_enable, 677 .disable = rockchip_vop_disable, 678 .fixup_dts = rockchip_vop_fixup_dts, 679 }; 680