1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (C) 2018 Linus Walleij <linus.walleij@linaro.org> 4 * Parts of this file were based on the MCDE driver by Marcus Lorentzon 5 * (C) ST-Ericsson SA 2013 6 */ 7 #include <linux/clk.h> 8 #include <linux/delay.h> 9 #include <linux/dma-buf.h> 10 #include <linux/regulator/consumer.h> 11 #include <linux/media-bus-format.h> 12 13 #include <drm/drm_atomic_helper.h> 14 #include <drm/drm_device.h> 15 #include <drm/drm_fb_dma_helper.h> 16 #include <drm/drm_fourcc.h> 17 #include <drm/drm_framebuffer.h> 18 #include <drm/drm_gem_atomic_helper.h> 19 #include <drm/drm_gem_dma_helper.h> 20 #include <drm/drm_mipi_dsi.h> 21 #include <drm/drm_panel.h> 22 #include <drm/drm_print.h> 23 #include <drm/drm_bridge.h> 24 #include <drm/drm_vblank.h> 25 #include <video/mipi_display.h> 26 27 #include "mcde_drm.h" 28 #include "mcde_display_regs.h" 29 30 enum mcde_fifo { 31 MCDE_FIFO_A, 32 MCDE_FIFO_B, 33 /* TODO: implement FIFO C0 and FIFO C1 */ 34 }; 35 36 enum mcde_channel { 37 MCDE_CHANNEL_0 = 0, 38 MCDE_CHANNEL_1, 39 MCDE_CHANNEL_2, 40 MCDE_CHANNEL_3, 41 }; 42 43 enum mcde_extsrc { 44 MCDE_EXTSRC_0 = 0, 45 MCDE_EXTSRC_1, 46 MCDE_EXTSRC_2, 47 MCDE_EXTSRC_3, 48 MCDE_EXTSRC_4, 49 MCDE_EXTSRC_5, 50 MCDE_EXTSRC_6, 51 MCDE_EXTSRC_7, 52 MCDE_EXTSRC_8, 53 MCDE_EXTSRC_9, 54 }; 55 56 enum mcde_overlay { 57 MCDE_OVERLAY_0 = 0, 58 MCDE_OVERLAY_1, 59 MCDE_OVERLAY_2, 60 MCDE_OVERLAY_3, 61 MCDE_OVERLAY_4, 62 MCDE_OVERLAY_5, 63 }; 64 65 enum mcde_formatter { 66 MCDE_DSI_FORMATTER_0 = 0, 67 MCDE_DSI_FORMATTER_1, 68 MCDE_DSI_FORMATTER_2, 69 MCDE_DSI_FORMATTER_3, 70 MCDE_DSI_FORMATTER_4, 71 MCDE_DSI_FORMATTER_5, 72 MCDE_DPI_FORMATTER_0, 73 MCDE_DPI_FORMATTER_1, 74 }; 75 76 void mcde_display_irq(struct mcde *mcde) 77 { 78 u32 mispp, misovl, mischnl; 79 bool vblank = false; 80 81 /* Handle display IRQs */ 82 mispp = readl(mcde->regs + MCDE_MISPP); 83 misovl = readl(mcde->regs + MCDE_MISOVL); 84 mischnl = readl(mcde->regs + MCDE_MISCHNL); 85 86 /* 87 * Handle IRQs from the DSI link. All IRQs from the DSI links 88 * are just latched onto the MCDE IRQ line, so we need to traverse 89 * any active DSI masters and check if an IRQ is originating from 90 * them. 91 * 92 * TODO: Currently only one DSI link is supported. 93 */ 94 if (!mcde->dpi_output && mcde_dsi_irq(mcde->mdsi)) { 95 u32 val; 96 97 /* 98 * In oneshot mode we do not send continuous updates 99 * to the display, instead we only push out updates when 100 * the update function is called, then we disable the 101 * flow on the channel once we get the TE IRQ. 102 */ 103 if (mcde->flow_mode == MCDE_COMMAND_ONESHOT_FLOW) { 104 spin_lock(&mcde->flow_lock); 105 if (--mcde->flow_active == 0) { 106 dev_dbg(mcde->dev, "TE0 IRQ\n"); 107 /* Disable FIFO A flow */ 108 val = readl(mcde->regs + MCDE_CRA0); 109 val &= ~MCDE_CRX0_FLOEN; 110 writel(val, mcde->regs + MCDE_CRA0); 111 } 112 spin_unlock(&mcde->flow_lock); 113 } 114 } 115 116 /* Vblank from one of the channels */ 117 if (mispp & MCDE_PP_VCMPA) { 118 dev_dbg(mcde->dev, "chnl A vblank IRQ\n"); 119 vblank = true; 120 } 121 if (mispp & MCDE_PP_VCMPB) { 122 dev_dbg(mcde->dev, "chnl B vblank IRQ\n"); 123 vblank = true; 124 } 125 if (mispp & MCDE_PP_VCMPC0) 126 dev_dbg(mcde->dev, "chnl C0 vblank IRQ\n"); 127 if (mispp & MCDE_PP_VCMPC1) 128 dev_dbg(mcde->dev, "chnl C1 vblank IRQ\n"); 129 if (mispp & MCDE_PP_VSCC0) 130 dev_dbg(mcde->dev, "chnl C0 TE IRQ\n"); 131 if (mispp & MCDE_PP_VSCC1) 132 dev_dbg(mcde->dev, "chnl C1 TE IRQ\n"); 133 writel(mispp, mcde->regs + MCDE_RISPP); 134 135 if (vblank) 136 drm_crtc_handle_vblank(&mcde->crtc); 137 138 if (misovl) 139 dev_info(mcde->dev, "some stray overlay IRQ %08x\n", misovl); 140 writel(misovl, mcde->regs + MCDE_RISOVL); 141 142 if (mischnl) 143 dev_info(mcde->dev, "some stray channel error IRQ %08x\n", 144 mischnl); 145 writel(mischnl, mcde->regs + MCDE_RISCHNL); 146 } 147 148 void mcde_display_disable_irqs(struct mcde *mcde) 149 { 150 /* Disable all IRQs */ 151 writel(0, mcde->regs + MCDE_IMSCPP); 152 writel(0, mcde->regs + MCDE_IMSCOVL); 153 writel(0, mcde->regs + MCDE_IMSCCHNL); 154 155 /* Clear any pending IRQs */ 156 writel(0xFFFFFFFF, mcde->regs + MCDE_RISPP); 157 writel(0xFFFFFFFF, mcde->regs + MCDE_RISOVL); 158 writel(0xFFFFFFFF, mcde->regs + MCDE_RISCHNL); 159 } 160 161 static int mcde_plane_helper_atomic_check(struct drm_plane *plane, 162 struct drm_atomic_commit *commit) 163 { 164 struct drm_plane_state *pstate = drm_atomic_get_new_plane_state(commit, plane); 165 struct drm_plane_state *old_pstate = drm_atomic_get_old_plane_state(commit, plane); 166 struct drm_crtc_state *cstate = NULL; 167 const struct drm_display_mode *mode; 168 struct drm_framebuffer *old_fb = old_pstate->fb; 169 struct drm_framebuffer *fb = pstate->fb; 170 int ret; 171 172 if (pstate->crtc) { 173 cstate = drm_atomic_get_crtc_state(commit, pstate->crtc); 174 if (IS_ERR(cstate)) 175 return PTR_ERR(cstate); 176 } 177 178 ret = drm_atomic_helper_check_plane_state(pstate, cstate, 179 DRM_PLANE_NO_SCALING, 180 DRM_PLANE_NO_SCALING, 181 false, false); 182 if (ret) 183 return ret; 184 185 if (!pstate->visible || !fb) 186 return 0; 187 188 mode = &cstate->mode; 189 190 u32 offset = drm_fb_dma_get_gem_addr(fb, pstate, 0); 191 192 /* FB base address must be dword aligned. */ 193 if (offset & 3) { 194 DRM_DEBUG_KMS("FB not 32-bit aligned\n"); 195 return -EINVAL; 196 } 197 198 /* 199 * There's no pitch register, the mode's hdisplay 200 * controls this. 201 */ 202 if (fb->pitches[0] != mode->hdisplay * fb->format->cpp[0]) { 203 DRM_DEBUG_KMS("can't handle pitches\n"); 204 return -EINVAL; 205 } 206 207 /* 208 * We can't change the FB format in a flicker-free 209 * manner (and only update it during CRTC enable). 210 */ 211 if (old_fb && old_fb->format != fb->format) 212 cstate->mode_changed = true; 213 214 return 0; 215 } 216 217 static int mcde_configure_extsrc(struct mcde *mcde, enum mcde_extsrc src, 218 u32 format) 219 { 220 u32 val; 221 u32 conf; 222 u32 cr; 223 224 switch (src) { 225 case MCDE_EXTSRC_0: 226 conf = MCDE_EXTSRC0CONF; 227 cr = MCDE_EXTSRC0CR; 228 break; 229 case MCDE_EXTSRC_1: 230 conf = MCDE_EXTSRC1CONF; 231 cr = MCDE_EXTSRC1CR; 232 break; 233 case MCDE_EXTSRC_2: 234 conf = MCDE_EXTSRC2CONF; 235 cr = MCDE_EXTSRC2CR; 236 break; 237 case MCDE_EXTSRC_3: 238 conf = MCDE_EXTSRC3CONF; 239 cr = MCDE_EXTSRC3CR; 240 break; 241 case MCDE_EXTSRC_4: 242 conf = MCDE_EXTSRC4CONF; 243 cr = MCDE_EXTSRC4CR; 244 break; 245 case MCDE_EXTSRC_5: 246 conf = MCDE_EXTSRC5CONF; 247 cr = MCDE_EXTSRC5CR; 248 break; 249 case MCDE_EXTSRC_6: 250 conf = MCDE_EXTSRC6CONF; 251 cr = MCDE_EXTSRC6CR; 252 break; 253 case MCDE_EXTSRC_7: 254 conf = MCDE_EXTSRC7CONF; 255 cr = MCDE_EXTSRC7CR; 256 break; 257 case MCDE_EXTSRC_8: 258 conf = MCDE_EXTSRC8CONF; 259 cr = MCDE_EXTSRC8CR; 260 break; 261 case MCDE_EXTSRC_9: 262 conf = MCDE_EXTSRC9CONF; 263 cr = MCDE_EXTSRC9CR; 264 break; 265 } 266 267 /* 268 * Configure external source 0 one buffer (buffer 0) 269 * primary overlay ID 0. 270 * From mcde_hw.c ovly_update_registers() in the vendor tree 271 */ 272 val = 0 << MCDE_EXTSRCXCONF_BUF_ID_SHIFT; 273 val |= 1 << MCDE_EXTSRCXCONF_BUF_NB_SHIFT; 274 val |= 0 << MCDE_EXTSRCXCONF_PRI_OVLID_SHIFT; 275 276 switch (format) { 277 case DRM_FORMAT_ARGB8888: 278 val |= MCDE_EXTSRCXCONF_BPP_ARGB8888 << 279 MCDE_EXTSRCXCONF_BPP_SHIFT; 280 break; 281 case DRM_FORMAT_ABGR8888: 282 val |= MCDE_EXTSRCXCONF_BPP_ARGB8888 << 283 MCDE_EXTSRCXCONF_BPP_SHIFT; 284 val |= MCDE_EXTSRCXCONF_BGR; 285 break; 286 case DRM_FORMAT_XRGB8888: 287 val |= MCDE_EXTSRCXCONF_BPP_XRGB8888 << 288 MCDE_EXTSRCXCONF_BPP_SHIFT; 289 break; 290 case DRM_FORMAT_XBGR8888: 291 val |= MCDE_EXTSRCXCONF_BPP_XRGB8888 << 292 MCDE_EXTSRCXCONF_BPP_SHIFT; 293 val |= MCDE_EXTSRCXCONF_BGR; 294 break; 295 case DRM_FORMAT_RGB888: 296 val |= MCDE_EXTSRCXCONF_BPP_RGB888 << 297 MCDE_EXTSRCXCONF_BPP_SHIFT; 298 break; 299 case DRM_FORMAT_BGR888: 300 val |= MCDE_EXTSRCXCONF_BPP_RGB888 << 301 MCDE_EXTSRCXCONF_BPP_SHIFT; 302 val |= MCDE_EXTSRCXCONF_BGR; 303 break; 304 case DRM_FORMAT_ARGB4444: 305 val |= MCDE_EXTSRCXCONF_BPP_ARGB4444 << 306 MCDE_EXTSRCXCONF_BPP_SHIFT; 307 break; 308 case DRM_FORMAT_ABGR4444: 309 val |= MCDE_EXTSRCXCONF_BPP_ARGB4444 << 310 MCDE_EXTSRCXCONF_BPP_SHIFT; 311 val |= MCDE_EXTSRCXCONF_BGR; 312 break; 313 case DRM_FORMAT_XRGB4444: 314 val |= MCDE_EXTSRCXCONF_BPP_RGB444 << 315 MCDE_EXTSRCXCONF_BPP_SHIFT; 316 break; 317 case DRM_FORMAT_XBGR4444: 318 val |= MCDE_EXTSRCXCONF_BPP_RGB444 << 319 MCDE_EXTSRCXCONF_BPP_SHIFT; 320 val |= MCDE_EXTSRCXCONF_BGR; 321 break; 322 case DRM_FORMAT_XRGB1555: 323 val |= MCDE_EXTSRCXCONF_BPP_IRGB1555 << 324 MCDE_EXTSRCXCONF_BPP_SHIFT; 325 break; 326 case DRM_FORMAT_XBGR1555: 327 val |= MCDE_EXTSRCXCONF_BPP_IRGB1555 << 328 MCDE_EXTSRCXCONF_BPP_SHIFT; 329 val |= MCDE_EXTSRCXCONF_BGR; 330 break; 331 case DRM_FORMAT_RGB565: 332 val |= MCDE_EXTSRCXCONF_BPP_RGB565 << 333 MCDE_EXTSRCXCONF_BPP_SHIFT; 334 break; 335 case DRM_FORMAT_BGR565: 336 val |= MCDE_EXTSRCXCONF_BPP_RGB565 << 337 MCDE_EXTSRCXCONF_BPP_SHIFT; 338 val |= MCDE_EXTSRCXCONF_BGR; 339 break; 340 case DRM_FORMAT_YUV422: 341 val |= MCDE_EXTSRCXCONF_BPP_YCBCR422 << 342 MCDE_EXTSRCXCONF_BPP_SHIFT; 343 break; 344 default: 345 dev_err(mcde->dev, "Unknown pixel format 0x%08x\n", 346 format); 347 return -EINVAL; 348 } 349 writel(val, mcde->regs + conf); 350 351 /* Software select, primary */ 352 val = MCDE_EXTSRCXCR_SEL_MOD_SOFTWARE_SEL; 353 val |= MCDE_EXTSRCXCR_MULTIOVL_CTRL_PRIMARY; 354 writel(val, mcde->regs + cr); 355 356 return 0; 357 } 358 359 static void mcde_configure_overlay(struct mcde *mcde, enum mcde_overlay ovl, 360 enum mcde_extsrc src, 361 enum mcde_channel ch, 362 const struct drm_display_mode *mode, 363 u32 format, int cpp) 364 { 365 u32 val; 366 u32 conf1; 367 u32 conf2; 368 u32 crop; 369 u32 ljinc; 370 u32 cr; 371 u32 comp; 372 u32 pixel_fetcher_watermark; 373 374 switch (ovl) { 375 case MCDE_OVERLAY_0: 376 conf1 = MCDE_OVL0CONF; 377 conf2 = MCDE_OVL0CONF2; 378 crop = MCDE_OVL0CROP; 379 ljinc = MCDE_OVL0LJINC; 380 cr = MCDE_OVL0CR; 381 comp = MCDE_OVL0COMP; 382 break; 383 case MCDE_OVERLAY_1: 384 conf1 = MCDE_OVL1CONF; 385 conf2 = MCDE_OVL1CONF2; 386 crop = MCDE_OVL1CROP; 387 ljinc = MCDE_OVL1LJINC; 388 cr = MCDE_OVL1CR; 389 comp = MCDE_OVL1COMP; 390 break; 391 case MCDE_OVERLAY_2: 392 conf1 = MCDE_OVL2CONF; 393 conf2 = MCDE_OVL2CONF2; 394 crop = MCDE_OVL2CROP; 395 ljinc = MCDE_OVL2LJINC; 396 cr = MCDE_OVL2CR; 397 comp = MCDE_OVL2COMP; 398 break; 399 case MCDE_OVERLAY_3: 400 conf1 = MCDE_OVL3CONF; 401 conf2 = MCDE_OVL3CONF2; 402 crop = MCDE_OVL3CROP; 403 ljinc = MCDE_OVL3LJINC; 404 cr = MCDE_OVL3CR; 405 comp = MCDE_OVL3COMP; 406 break; 407 case MCDE_OVERLAY_4: 408 conf1 = MCDE_OVL4CONF; 409 conf2 = MCDE_OVL4CONF2; 410 crop = MCDE_OVL4CROP; 411 ljinc = MCDE_OVL4LJINC; 412 cr = MCDE_OVL4CR; 413 comp = MCDE_OVL4COMP; 414 break; 415 case MCDE_OVERLAY_5: 416 conf1 = MCDE_OVL5CONF; 417 conf2 = MCDE_OVL5CONF2; 418 crop = MCDE_OVL5CROP; 419 ljinc = MCDE_OVL5LJINC; 420 cr = MCDE_OVL5CR; 421 comp = MCDE_OVL5COMP; 422 break; 423 } 424 425 val = mode->hdisplay << MCDE_OVLXCONF_PPL_SHIFT; 426 val |= mode->vdisplay << MCDE_OVLXCONF_LPF_SHIFT; 427 /* Use external source 0 that we just configured */ 428 val |= src << MCDE_OVLXCONF_EXTSRC_ID_SHIFT; 429 writel(val, mcde->regs + conf1); 430 431 val = MCDE_OVLXCONF2_BP_PER_PIXEL_ALPHA; 432 val |= 0xff << MCDE_OVLXCONF2_ALPHAVALUE_SHIFT; 433 /* OPQ: overlay is opaque */ 434 switch (format) { 435 case DRM_FORMAT_ARGB8888: 436 case DRM_FORMAT_ABGR8888: 437 case DRM_FORMAT_ARGB4444: 438 case DRM_FORMAT_ABGR4444: 439 case DRM_FORMAT_XRGB1555: 440 case DRM_FORMAT_XBGR1555: 441 /* No OPQ */ 442 break; 443 case DRM_FORMAT_XRGB8888: 444 case DRM_FORMAT_XBGR8888: 445 case DRM_FORMAT_RGB888: 446 case DRM_FORMAT_BGR888: 447 case DRM_FORMAT_RGB565: 448 case DRM_FORMAT_BGR565: 449 case DRM_FORMAT_YUV422: 450 val |= MCDE_OVLXCONF2_OPQ; 451 break; 452 default: 453 dev_err(mcde->dev, "Unknown pixel format 0x%08x\n", 454 format); 455 break; 456 } 457 458 /* 459 * Pixel fetch watermark level is max 0x1FFF pixels. 460 * Two basic rules should be followed: 461 * 1. The value should be at least 256 bits. 462 * 2. The sum of all active overlays pixelfetch watermark level 463 * multiplied with bits per pixel, should be lower than the 464 * size of input_fifo_size in bits. 465 * 3. The value should be a multiple of a line (256 bits). 466 */ 467 switch (cpp) { 468 case 2: 469 pixel_fetcher_watermark = 128; 470 break; 471 case 3: 472 pixel_fetcher_watermark = 96; 473 break; 474 case 4: 475 pixel_fetcher_watermark = 48; 476 break; 477 default: 478 pixel_fetcher_watermark = 48; 479 break; 480 } 481 dev_dbg(mcde->dev, "pixel fetcher watermark level %d pixels\n", 482 pixel_fetcher_watermark); 483 val |= pixel_fetcher_watermark << MCDE_OVLXCONF2_PIXELFETCHERWATERMARKLEVEL_SHIFT; 484 writel(val, mcde->regs + conf2); 485 486 /* Number of bytes to fetch per line */ 487 writel(mcde->stride, mcde->regs + ljinc); 488 /* No cropping */ 489 writel(0, mcde->regs + crop); 490 491 /* Set up overlay control register */ 492 val = MCDE_OVLXCR_OVLEN; 493 val |= MCDE_OVLXCR_COLCCTRL_DISABLED; 494 val |= MCDE_OVLXCR_BURSTSIZE_8W << 495 MCDE_OVLXCR_BURSTSIZE_SHIFT; 496 val |= MCDE_OVLXCR_MAXOUTSTANDING_8_REQ << 497 MCDE_OVLXCR_MAXOUTSTANDING_SHIFT; 498 /* Not using rotation but set it up anyways */ 499 val |= MCDE_OVLXCR_ROTBURSTSIZE_8W << 500 MCDE_OVLXCR_ROTBURSTSIZE_SHIFT; 501 writel(val, mcde->regs + cr); 502 503 /* 504 * Set up the overlay compositor to route the overlay out to 505 * the desired channel 506 */ 507 val = ch << MCDE_OVLXCOMP_CH_ID_SHIFT; 508 writel(val, mcde->regs + comp); 509 } 510 511 static void mcde_configure_channel(struct mcde *mcde, enum mcde_channel ch, 512 enum mcde_fifo fifo, 513 const struct drm_display_mode *mode) 514 { 515 u32 val; 516 u32 conf; 517 u32 sync; 518 u32 stat; 519 u32 bgcol; 520 u32 mux; 521 522 switch (ch) { 523 case MCDE_CHANNEL_0: 524 conf = MCDE_CHNL0CONF; 525 sync = MCDE_CHNL0SYNCHMOD; 526 stat = MCDE_CHNL0STAT; 527 bgcol = MCDE_CHNL0BCKGNDCOL; 528 mux = MCDE_CHNL0MUXING; 529 break; 530 case MCDE_CHANNEL_1: 531 conf = MCDE_CHNL1CONF; 532 sync = MCDE_CHNL1SYNCHMOD; 533 stat = MCDE_CHNL1STAT; 534 bgcol = MCDE_CHNL1BCKGNDCOL; 535 mux = MCDE_CHNL1MUXING; 536 break; 537 case MCDE_CHANNEL_2: 538 conf = MCDE_CHNL2CONF; 539 sync = MCDE_CHNL2SYNCHMOD; 540 stat = MCDE_CHNL2STAT; 541 bgcol = MCDE_CHNL2BCKGNDCOL; 542 mux = MCDE_CHNL2MUXING; 543 break; 544 case MCDE_CHANNEL_3: 545 conf = MCDE_CHNL3CONF; 546 sync = MCDE_CHNL3SYNCHMOD; 547 stat = MCDE_CHNL3STAT; 548 bgcol = MCDE_CHNL3BCKGNDCOL; 549 mux = MCDE_CHNL3MUXING; 550 return; 551 } 552 553 /* Set up channel 0 sync (based on chnl_update_registers()) */ 554 switch (mcde->flow_mode) { 555 case MCDE_COMMAND_ONESHOT_FLOW: 556 /* Oneshot is achieved with software sync */ 557 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SOFTWARE 558 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT; 559 break; 560 case MCDE_COMMAND_TE_FLOW: 561 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE 562 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT; 563 val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_TE0 564 << MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT; 565 break; 566 case MCDE_COMMAND_BTA_TE_FLOW: 567 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE 568 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT; 569 /* 570 * TODO: 571 * The vendor driver uses the formatter as sync source 572 * for BTA TE mode. Test to use TE if you have a panel 573 * that uses this mode. 574 */ 575 val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_FORMATTER 576 << MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT; 577 break; 578 case MCDE_VIDEO_TE_FLOW: 579 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE 580 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT; 581 val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_TE0 582 << MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT; 583 break; 584 case MCDE_VIDEO_FORMATTER_FLOW: 585 case MCDE_DPI_FORMATTER_FLOW: 586 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE 587 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT; 588 val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_FORMATTER 589 << MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT; 590 break; 591 default: 592 dev_err(mcde->dev, "unknown flow mode %d\n", 593 mcde->flow_mode); 594 return; 595 } 596 597 writel(val, mcde->regs + sync); 598 599 /* Set up pixels per line and lines per frame */ 600 val = (mode->hdisplay - 1) << MCDE_CHNLXCONF_PPL_SHIFT; 601 val |= (mode->vdisplay - 1) << MCDE_CHNLXCONF_LPF_SHIFT; 602 writel(val, mcde->regs + conf); 603 604 /* 605 * Normalize color conversion: 606 * black background, OLED conversion disable on channel 607 */ 608 val = MCDE_CHNLXSTAT_CHNLBLBCKGND_EN | 609 MCDE_CHNLXSTAT_CHNLRD; 610 writel(val, mcde->regs + stat); 611 writel(0, mcde->regs + bgcol); 612 613 /* Set up muxing: connect the channel to the desired FIFO */ 614 switch (fifo) { 615 case MCDE_FIFO_A: 616 writel(MCDE_CHNLXMUXING_FIFO_ID_FIFO_A, 617 mcde->regs + mux); 618 break; 619 case MCDE_FIFO_B: 620 writel(MCDE_CHNLXMUXING_FIFO_ID_FIFO_B, 621 mcde->regs + mux); 622 break; 623 } 624 625 /* 626 * If using DPI configure the sync event. 627 * TODO: this is for LCD only, it does not cover TV out. 628 */ 629 if (mcde->dpi_output) { 630 u32 stripwidth; 631 632 stripwidth = 0xF000 / (mode->vdisplay * 4); 633 dev_info(mcde->dev, "stripwidth: %d\n", stripwidth); 634 635 val = MCDE_SYNCHCONF_HWREQVEVENT_ACTIVE_VIDEO | 636 (mode->hdisplay - 1 - stripwidth) << MCDE_SYNCHCONF_HWREQVCNT_SHIFT | 637 MCDE_SYNCHCONF_SWINTVEVENT_ACTIVE_VIDEO | 638 (mode->hdisplay - 1 - stripwidth) << MCDE_SYNCHCONF_SWINTVCNT_SHIFT; 639 640 switch (fifo) { 641 case MCDE_FIFO_A: 642 writel(val, mcde->regs + MCDE_SYNCHCONFA); 643 break; 644 case MCDE_FIFO_B: 645 writel(val, mcde->regs + MCDE_SYNCHCONFB); 646 break; 647 } 648 } 649 } 650 651 static void mcde_configure_fifo(struct mcde *mcde, enum mcde_fifo fifo, 652 enum mcde_formatter fmt, 653 int fifo_wtrmrk) 654 { 655 u32 val; 656 u32 ctrl; 657 u32 cr0, cr1; 658 659 switch (fifo) { 660 case MCDE_FIFO_A: 661 ctrl = MCDE_CTRLA; 662 cr0 = MCDE_CRA0; 663 cr1 = MCDE_CRA1; 664 break; 665 case MCDE_FIFO_B: 666 ctrl = MCDE_CTRLB; 667 cr0 = MCDE_CRB0; 668 cr1 = MCDE_CRB1; 669 break; 670 } 671 672 val = fifo_wtrmrk << MCDE_CTRLX_FIFOWTRMRK_SHIFT; 673 674 /* 675 * Select the formatter to use for this FIFO 676 * 677 * The register definitions imply that different IDs should be used 678 * by the DSI formatters depending on if they are in VID or CMD 679 * mode, and the manual says they are dedicated but identical. 680 * The vendor code uses them as it seems fit. 681 */ 682 switch (fmt) { 683 case MCDE_DSI_FORMATTER_0: 684 val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT; 685 val |= MCDE_CTRLX_FORMID_DSI0VID << MCDE_CTRLX_FORMID_SHIFT; 686 break; 687 case MCDE_DSI_FORMATTER_1: 688 val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT; 689 val |= MCDE_CTRLX_FORMID_DSI0CMD << MCDE_CTRLX_FORMID_SHIFT; 690 break; 691 case MCDE_DSI_FORMATTER_2: 692 val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT; 693 val |= MCDE_CTRLX_FORMID_DSI1VID << MCDE_CTRLX_FORMID_SHIFT; 694 break; 695 case MCDE_DSI_FORMATTER_3: 696 val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT; 697 val |= MCDE_CTRLX_FORMID_DSI1CMD << MCDE_CTRLX_FORMID_SHIFT; 698 break; 699 case MCDE_DSI_FORMATTER_4: 700 val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT; 701 val |= MCDE_CTRLX_FORMID_DSI2VID << MCDE_CTRLX_FORMID_SHIFT; 702 break; 703 case MCDE_DSI_FORMATTER_5: 704 val |= MCDE_CTRLX_FORMTYPE_DSI << MCDE_CTRLX_FORMTYPE_SHIFT; 705 val |= MCDE_CTRLX_FORMID_DSI2CMD << MCDE_CTRLX_FORMID_SHIFT; 706 break; 707 case MCDE_DPI_FORMATTER_0: 708 val |= MCDE_CTRLX_FORMTYPE_DPITV << MCDE_CTRLX_FORMTYPE_SHIFT; 709 val |= MCDE_CTRLX_FORMID_DPIA << MCDE_CTRLX_FORMID_SHIFT; 710 break; 711 case MCDE_DPI_FORMATTER_1: 712 val |= MCDE_CTRLX_FORMTYPE_DPITV << MCDE_CTRLX_FORMTYPE_SHIFT; 713 val |= MCDE_CTRLX_FORMID_DPIB << MCDE_CTRLX_FORMID_SHIFT; 714 break; 715 } 716 writel(val, mcde->regs + ctrl); 717 718 /* Blend source with Alpha 0xff on FIFO */ 719 val = MCDE_CRX0_BLENDEN | 720 0xff << MCDE_CRX0_ALPHABLEND_SHIFT; 721 writel(val, mcde->regs + cr0); 722 723 spin_lock(&mcde->fifo_crx1_lock); 724 val = readl(mcde->regs + cr1); 725 /* 726 * Set-up from mcde_fmtr_dsi.c, fmtr_dsi_enable_video() 727 * FIXME: a different clock needs to be selected for TV out. 728 */ 729 if (mcde->dpi_output) { 730 struct drm_connector *connector = drm_panel_bridge_connector(mcde->bridge); 731 u32 bus_format; 732 733 /* Assume RGB888 24 bit if we have no further info */ 734 if (!connector->display_info.num_bus_formats) { 735 dev_info(mcde->dev, "panel does not specify bus format, assume RGB888\n"); 736 bus_format = MEDIA_BUS_FMT_RGB888_1X24; 737 } else { 738 bus_format = connector->display_info.bus_formats[0]; 739 } 740 741 /* 742 * Set up the CDWIN and OUTBPP for the LCD 743 * 744 * FIXME: fill this in if you know the correspondance between the MIPI 745 * DPI specification and the media bus formats. 746 */ 747 val &= ~MCDE_CRX1_CDWIN_MASK; 748 val &= ~MCDE_CRX1_OUTBPP_MASK; 749 switch (bus_format) { 750 case MEDIA_BUS_FMT_RGB888_1X24: 751 val |= MCDE_CRX1_CDWIN_24BPP << MCDE_CRX1_CDWIN_SHIFT; 752 val |= MCDE_CRX1_OUTBPP_24BPP << MCDE_CRX1_OUTBPP_SHIFT; 753 break; 754 default: 755 dev_err(mcde->dev, "unknown bus format, assume RGB888\n"); 756 val |= MCDE_CRX1_CDWIN_24BPP << MCDE_CRX1_CDWIN_SHIFT; 757 val |= MCDE_CRX1_OUTBPP_24BPP << MCDE_CRX1_OUTBPP_SHIFT; 758 break; 759 } 760 } else { 761 /* Use the MCDE clock for DSI */ 762 val &= ~MCDE_CRX1_CLKSEL_MASK; 763 val |= MCDE_CRX1_CLKSEL_MCDECLK << MCDE_CRX1_CLKSEL_SHIFT; 764 } 765 writel(val, mcde->regs + cr1); 766 spin_unlock(&mcde->fifo_crx1_lock); 767 }; 768 769 static void mcde_configure_dsi_formatter(struct mcde *mcde, 770 enum mcde_formatter fmt, 771 u32 formatter_frame, 772 int pkt_size) 773 { 774 u32 val; 775 u32 conf0; 776 u32 frame; 777 u32 pkt; 778 u32 sync; 779 u32 cmdw; 780 u32 delay0, delay1; 781 782 switch (fmt) { 783 case MCDE_DSI_FORMATTER_0: 784 conf0 = MCDE_DSIVID0CONF0; 785 frame = MCDE_DSIVID0FRAME; 786 pkt = MCDE_DSIVID0PKT; 787 sync = MCDE_DSIVID0SYNC; 788 cmdw = MCDE_DSIVID0CMDW; 789 delay0 = MCDE_DSIVID0DELAY0; 790 delay1 = MCDE_DSIVID0DELAY1; 791 break; 792 case MCDE_DSI_FORMATTER_1: 793 conf0 = MCDE_DSIVID1CONF0; 794 frame = MCDE_DSIVID1FRAME; 795 pkt = MCDE_DSIVID1PKT; 796 sync = MCDE_DSIVID1SYNC; 797 cmdw = MCDE_DSIVID1CMDW; 798 delay0 = MCDE_DSIVID1DELAY0; 799 delay1 = MCDE_DSIVID1DELAY1; 800 break; 801 case MCDE_DSI_FORMATTER_2: 802 conf0 = MCDE_DSIVID2CONF0; 803 frame = MCDE_DSIVID2FRAME; 804 pkt = MCDE_DSIVID2PKT; 805 sync = MCDE_DSIVID2SYNC; 806 cmdw = MCDE_DSIVID2CMDW; 807 delay0 = MCDE_DSIVID2DELAY0; 808 delay1 = MCDE_DSIVID2DELAY1; 809 break; 810 default: 811 dev_err(mcde->dev, "tried to configure a non-DSI formatter as DSI\n"); 812 return; 813 } 814 815 /* 816 * Enable formatter 817 * 8 bit commands and DCS commands (notgen = not generic) 818 */ 819 val = MCDE_DSICONF0_CMD8 | MCDE_DSICONF0_DCSVID_NOTGEN; 820 if (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) 821 val |= MCDE_DSICONF0_VID_MODE_VID; 822 switch (mcde->mdsi->format) { 823 case MIPI_DSI_FMT_RGB888: 824 val |= MCDE_DSICONF0_PACKING_RGB888 << 825 MCDE_DSICONF0_PACKING_SHIFT; 826 break; 827 case MIPI_DSI_FMT_RGB666: 828 val |= MCDE_DSICONF0_PACKING_RGB666 << 829 MCDE_DSICONF0_PACKING_SHIFT; 830 break; 831 case MIPI_DSI_FMT_RGB666_PACKED: 832 dev_err(mcde->dev, 833 "we cannot handle the packed RGB666 format\n"); 834 val |= MCDE_DSICONF0_PACKING_RGB666 << 835 MCDE_DSICONF0_PACKING_SHIFT; 836 break; 837 case MIPI_DSI_FMT_RGB565: 838 val |= MCDE_DSICONF0_PACKING_RGB565 << 839 MCDE_DSICONF0_PACKING_SHIFT; 840 break; 841 default: 842 dev_err(mcde->dev, "unknown DSI format\n"); 843 return; 844 } 845 writel(val, mcde->regs + conf0); 846 847 writel(formatter_frame, mcde->regs + frame); 848 writel(pkt_size, mcde->regs + pkt); 849 writel(0, mcde->regs + sync); 850 /* Define the MIPI command: we want to write into display memory */ 851 val = MIPI_DCS_WRITE_MEMORY_CONTINUE << 852 MCDE_DSIVIDXCMDW_CMDW_CONTINUE_SHIFT; 853 val |= MIPI_DCS_WRITE_MEMORY_START << 854 MCDE_DSIVIDXCMDW_CMDW_START_SHIFT; 855 writel(val, mcde->regs + cmdw); 856 857 /* 858 * FIXME: the vendor driver has some hack around this value in 859 * CMD mode with autotrig. 860 */ 861 writel(0, mcde->regs + delay0); 862 writel(0, mcde->regs + delay1); 863 } 864 865 static void mcde_enable_fifo(struct mcde *mcde, enum mcde_fifo fifo) 866 { 867 u32 val; 868 u32 cr; 869 870 switch (fifo) { 871 case MCDE_FIFO_A: 872 cr = MCDE_CRA0; 873 break; 874 case MCDE_FIFO_B: 875 cr = MCDE_CRB0; 876 break; 877 default: 878 dev_err(mcde->dev, "cannot enable FIFO %c\n", 879 'A' + fifo); 880 return; 881 } 882 883 spin_lock(&mcde->flow_lock); 884 val = readl(mcde->regs + cr); 885 val |= MCDE_CRX0_FLOEN; 886 writel(val, mcde->regs + cr); 887 mcde->flow_active++; 888 spin_unlock(&mcde->flow_lock); 889 } 890 891 static void mcde_disable_fifo(struct mcde *mcde, enum mcde_fifo fifo, 892 bool wait_for_drain) 893 { 894 int timeout = 100; 895 u32 val; 896 u32 cr; 897 898 switch (fifo) { 899 case MCDE_FIFO_A: 900 cr = MCDE_CRA0; 901 break; 902 case MCDE_FIFO_B: 903 cr = MCDE_CRB0; 904 break; 905 default: 906 dev_err(mcde->dev, "cannot disable FIFO %c\n", 907 'A' + fifo); 908 return; 909 } 910 911 spin_lock(&mcde->flow_lock); 912 val = readl(mcde->regs + cr); 913 val &= ~MCDE_CRX0_FLOEN; 914 writel(val, mcde->regs + cr); 915 mcde->flow_active = 0; 916 spin_unlock(&mcde->flow_lock); 917 918 if (!wait_for_drain) 919 return; 920 921 /* Check that we really drained and stopped the flow */ 922 while (readl(mcde->regs + cr) & MCDE_CRX0_FLOEN) { 923 usleep_range(1000, 1500); 924 if (!--timeout) { 925 dev_err(mcde->dev, 926 "FIFO timeout while clearing FIFO %c\n", 927 'A' + fifo); 928 return; 929 } 930 } 931 } 932 933 /* 934 * This drains a pipe i.e. a FIFO connected to a certain channel 935 */ 936 static void mcde_drain_pipe(struct mcde *mcde, enum mcde_fifo fifo, 937 enum mcde_channel ch) 938 { 939 u32 val; 940 u32 ctrl; 941 u32 synsw; 942 943 switch (fifo) { 944 case MCDE_FIFO_A: 945 ctrl = MCDE_CTRLA; 946 break; 947 case MCDE_FIFO_B: 948 ctrl = MCDE_CTRLB; 949 break; 950 } 951 952 switch (ch) { 953 case MCDE_CHANNEL_0: 954 synsw = MCDE_CHNL0SYNCHSW; 955 break; 956 case MCDE_CHANNEL_1: 957 synsw = MCDE_CHNL1SYNCHSW; 958 break; 959 case MCDE_CHANNEL_2: 960 synsw = MCDE_CHNL2SYNCHSW; 961 break; 962 case MCDE_CHANNEL_3: 963 synsw = MCDE_CHNL3SYNCHSW; 964 return; 965 } 966 967 val = readl(mcde->regs + ctrl); 968 if (!(val & MCDE_CTRLX_FIFOEMPTY)) { 969 dev_err(mcde->dev, "Channel A FIFO not empty (handover)\n"); 970 /* Attempt to clear the FIFO */ 971 mcde_enable_fifo(mcde, fifo); 972 /* Trigger a software sync out on respective channel (0-3) */ 973 writel(MCDE_CHNLXSYNCHSW_SW_TRIG, mcde->regs + synsw); 974 /* Disable FIFO A flow again */ 975 mcde_disable_fifo(mcde, fifo, true); 976 } 977 } 978 979 static int mcde_dsi_get_pkt_div(int ppl, int fifo_size) 980 { 981 /* 982 * DSI command mode line packets should be split into an even number of 983 * packets smaller than or equal to the fifo size. 984 */ 985 int div; 986 const int max_div = DIV_ROUND_UP(MCDE_MAX_WIDTH, fifo_size); 987 988 for (div = 1; div < max_div; div++) 989 if (ppl % div == 0 && ppl / div <= fifo_size) 990 return div; 991 return 1; 992 } 993 994 static void mcde_setup_dpi(struct mcde *mcde, const struct drm_display_mode *mode, 995 int *fifo_wtrmrk_lvl) 996 { 997 struct drm_connector *connector = drm_panel_bridge_connector(mcde->bridge); 998 u32 hsw, hfp, hbp; 999 u32 vsw, vfp, vbp; 1000 u32 val; 1001 1002 /* FIXME: we only support LCD, implement TV out */ 1003 hsw = mode->hsync_end - mode->hsync_start; 1004 hfp = mode->hsync_start - mode->hdisplay; 1005 hbp = mode->htotal - mode->hsync_end; 1006 vsw = mode->vsync_end - mode->vsync_start; 1007 vfp = mode->vsync_start - mode->vdisplay; 1008 vbp = mode->vtotal - mode->vsync_end; 1009 1010 dev_info(mcde->dev, "output on DPI LCD from channel A\n"); 1011 /* Display actual values */ 1012 dev_info(mcde->dev, "HSW: %d, HFP: %d, HBP: %d, VSW: %d, VFP: %d, VBP: %d\n", 1013 hsw, hfp, hbp, vsw, vfp, vbp); 1014 1015 /* 1016 * The pixel fetcher is 128 64-bit words deep = 1024 bytes. 1017 * One overlay of 32bpp (4 cpp) assumed, fetch 160 pixels. 1018 * 160 * 4 = 640 bytes. 1019 */ 1020 *fifo_wtrmrk_lvl = 640; 1021 1022 /* Set up the main control, watermark level at 7 */ 1023 val = 7 << MCDE_CONF0_IFIFOCTRLWTRMRKLVL_SHIFT; 1024 1025 /* 1026 * This sets up the internal silicon muxing of the DPI 1027 * lines. This is how the silicon connects out to the 1028 * external pins, then the pins need to be further 1029 * configured into "alternate functions" using pin control 1030 * to actually get the signals out. 1031 * 1032 * FIXME: this is hardcoded to the only setting found in 1033 * the wild. If we need to use different settings for 1034 * different DPI displays, make this parameterizable from 1035 * the device tree. 1036 */ 1037 /* 24 bits DPI: connect Ch A LSB to D[0:7] */ 1038 val |= 0 << MCDE_CONF0_OUTMUX0_SHIFT; 1039 /* 24 bits DPI: connect Ch A MID to D[8:15] */ 1040 val |= 1 << MCDE_CONF0_OUTMUX1_SHIFT; 1041 /* Don't care about this muxing */ 1042 val |= 0 << MCDE_CONF0_OUTMUX2_SHIFT; 1043 /* Don't care about this muxing */ 1044 val |= 0 << MCDE_CONF0_OUTMUX3_SHIFT; 1045 /* 24 bits DPI: connect Ch A MSB to D[32:39] */ 1046 val |= 2 << MCDE_CONF0_OUTMUX4_SHIFT; 1047 /* Syncmux bits zero: DPI channel A */ 1048 writel(val, mcde->regs + MCDE_CONF0); 1049 1050 /* This hammers us into LCD mode */ 1051 writel(0, mcde->regs + MCDE_TVCRA); 1052 1053 /* Front porch and sync width */ 1054 val = (vsw << MCDE_TVBL1_BEL1_SHIFT); 1055 val |= (vfp << MCDE_TVBL1_BSL1_SHIFT); 1056 writel(val, mcde->regs + MCDE_TVBL1A); 1057 /* The vendor driver sets the same value into TVBL2A */ 1058 writel(val, mcde->regs + MCDE_TVBL2A); 1059 1060 /* Vertical back porch */ 1061 val = (vbp << MCDE_TVDVO_DVO1_SHIFT); 1062 /* The vendor drivers sets the same value into TVDVOA */ 1063 val |= (vbp << MCDE_TVDVO_DVO2_SHIFT); 1064 writel(val, mcde->regs + MCDE_TVDVOA); 1065 1066 /* Horizontal back porch, as 0 = 1 cycle we need to subtract 1 */ 1067 writel((hbp - 1), mcde->regs + MCDE_TVTIM1A); 1068 1069 /* Horizongal sync width and horizonal front porch, 0 = 1 cycle */ 1070 val = ((hsw - 1) << MCDE_TVLBALW_LBW_SHIFT); 1071 val |= ((hfp - 1) << MCDE_TVLBALW_ALW_SHIFT); 1072 writel(val, mcde->regs + MCDE_TVLBALWA); 1073 1074 /* Blank some TV registers we don't use */ 1075 writel(0, mcde->regs + MCDE_TVISLA); 1076 writel(0, mcde->regs + MCDE_TVBLUA); 1077 1078 /* Set up sync inversion etc */ 1079 val = 0; 1080 if (mode->flags & DRM_MODE_FLAG_NHSYNC) 1081 val |= MCDE_LCDTIM1B_IHS; 1082 if (mode->flags & DRM_MODE_FLAG_NVSYNC) 1083 val |= MCDE_LCDTIM1B_IVS; 1084 if (connector->display_info.bus_flags & DRM_BUS_FLAG_DE_LOW) 1085 val |= MCDE_LCDTIM1B_IOE; 1086 if (connector->display_info.bus_flags & DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE) 1087 val |= MCDE_LCDTIM1B_IPC; 1088 writel(val, mcde->regs + MCDE_LCDTIM1A); 1089 } 1090 1091 static void mcde_setup_dsi(struct mcde *mcde, const struct drm_display_mode *mode, 1092 int cpp, int *fifo_wtrmrk_lvl, int *dsi_formatter_frame, 1093 int *dsi_pkt_size) 1094 { 1095 u32 formatter_ppl = mode->hdisplay; /* pixels per line */ 1096 u32 formatter_lpf = mode->vdisplay; /* lines per frame */ 1097 int formatter_frame; 1098 int formatter_cpp; 1099 int fifo_wtrmrk; 1100 u32 pkt_div; 1101 int pkt_size; 1102 u32 val; 1103 1104 dev_info(mcde->dev, "output in %s mode, format %dbpp\n", 1105 (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) ? 1106 "VIDEO" : "CMD", 1107 mipi_dsi_pixel_format_to_bpp(mcde->mdsi->format)); 1108 formatter_cpp = 1109 mipi_dsi_pixel_format_to_bpp(mcde->mdsi->format) / 8; 1110 dev_info(mcde->dev, "Overlay CPP: %d bytes, DSI formatter CPP %d bytes\n", 1111 cpp, formatter_cpp); 1112 1113 /* Set up the main control, watermark level at 7 */ 1114 val = 7 << MCDE_CONF0_IFIFOCTRLWTRMRKLVL_SHIFT; 1115 1116 /* 1117 * This is the internal silicon muxing of the DPI 1118 * (parallell display) lines. Since we are not using 1119 * this at all (we are using DSI) these are just 1120 * dummy values from the vendor tree. 1121 */ 1122 val |= 3 << MCDE_CONF0_OUTMUX0_SHIFT; 1123 val |= 3 << MCDE_CONF0_OUTMUX1_SHIFT; 1124 val |= 0 << MCDE_CONF0_OUTMUX2_SHIFT; 1125 val |= 4 << MCDE_CONF0_OUTMUX3_SHIFT; 1126 val |= 5 << MCDE_CONF0_OUTMUX4_SHIFT; 1127 writel(val, mcde->regs + MCDE_CONF0); 1128 1129 /* Calculations from mcde_fmtr_dsi.c, fmtr_dsi_enable_video() */ 1130 1131 /* 1132 * Set up FIFO A watermark level: 1133 * 128 for LCD 32bpp video mode 1134 * 48 for LCD 32bpp command mode 1135 * 128 for LCD 16bpp video mode 1136 * 64 for LCD 16bpp command mode 1137 * 128 for HDMI 32bpp 1138 * 192 for HDMI 16bpp 1139 */ 1140 fifo_wtrmrk = mode->hdisplay; 1141 if (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) { 1142 fifo_wtrmrk = min(fifo_wtrmrk, 128); 1143 pkt_div = 1; 1144 } else { 1145 fifo_wtrmrk = min(fifo_wtrmrk, 48); 1146 /* The FIFO is 640 entries deep on this v3 hardware */ 1147 pkt_div = mcde_dsi_get_pkt_div(mode->hdisplay, 640); 1148 } 1149 dev_dbg(mcde->dev, "FIFO watermark after flooring: %d bytes\n", 1150 fifo_wtrmrk); 1151 dev_dbg(mcde->dev, "Packet divisor: %d bytes\n", pkt_div); 1152 1153 /* NOTE: pkt_div is 1 for video mode */ 1154 pkt_size = (formatter_ppl * formatter_cpp) / pkt_div; 1155 /* Commands CMD8 need one extra byte */ 1156 if (!(mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO)) 1157 pkt_size++; 1158 1159 dev_dbg(mcde->dev, "DSI packet size: %d * %d bytes per line\n", 1160 pkt_size, pkt_div); 1161 dev_dbg(mcde->dev, "Overlay frame size: %u bytes\n", 1162 mode->hdisplay * mode->vdisplay * cpp); 1163 /* NOTE: pkt_div is 1 for video mode */ 1164 formatter_frame = pkt_size * pkt_div * formatter_lpf; 1165 dev_dbg(mcde->dev, "Formatter frame size: %u bytes\n", formatter_frame); 1166 1167 *fifo_wtrmrk_lvl = fifo_wtrmrk; 1168 *dsi_pkt_size = pkt_size; 1169 *dsi_formatter_frame = formatter_frame; 1170 } 1171 1172 static void mcde_crtc_helper_atomic_enable(struct drm_crtc *crtc, 1173 struct drm_atomic_commit *commit) 1174 { 1175 struct drm_device *drm = crtc->dev; 1176 struct mcde *mcde = to_mcde(drm); 1177 struct drm_crtc_state *cstate = drm_atomic_get_new_crtc_state(commit, crtc); 1178 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(commit, &mcde->plane); 1179 const struct drm_display_mode *mode = &cstate->mode; 1180 struct drm_framebuffer *fb = plane_state->fb; 1181 u32 format = fb->format->format; 1182 int dsi_pkt_size; 1183 int fifo_wtrmrk; 1184 int cpp = fb->format->cpp[0]; 1185 u32 dsi_formatter_frame; 1186 u32 val; 1187 int ret; 1188 1189 /* This powers up the entire MCDE block and the DSI hardware */ 1190 ret = regulator_enable(mcde->epod); 1191 if (ret) { 1192 dev_err(drm->dev, "can't re-enable EPOD regulator\n"); 1193 return; 1194 } 1195 1196 dev_info(drm->dev, "enable MCDE, %d x %d format %p4cc\n", 1197 mode->hdisplay, mode->vdisplay, &format); 1198 1199 1200 /* Clear any pending interrupts */ 1201 mcde_display_disable_irqs(mcde); 1202 writel(0, mcde->regs + MCDE_IMSCERR); 1203 writel(0xFFFFFFFF, mcde->regs + MCDE_RISERR); 1204 1205 if (mcde->dpi_output) 1206 mcde_setup_dpi(mcde, mode, &fifo_wtrmrk); 1207 else 1208 mcde_setup_dsi(mcde, mode, cpp, &fifo_wtrmrk, 1209 &dsi_formatter_frame, &dsi_pkt_size); 1210 1211 mcde->stride = mode->hdisplay * cpp; 1212 dev_dbg(drm->dev, "Overlay line stride: %u bytes\n", 1213 mcde->stride); 1214 1215 /* Drain the FIFO A + channel 0 pipe so we have a clean slate */ 1216 mcde_drain_pipe(mcde, MCDE_FIFO_A, MCDE_CHANNEL_0); 1217 1218 /* 1219 * We set up our display pipeline: 1220 * EXTSRC 0 -> OVERLAY 0 -> CHANNEL 0 -> FIFO A -> DSI FORMATTER 0 1221 * 1222 * First configure the external source (memory) on external source 0 1223 * using the desired bitstream/bitmap format 1224 */ 1225 mcde_configure_extsrc(mcde, MCDE_EXTSRC_0, format); 1226 1227 /* 1228 * Configure overlay 0 according to format and mode and take input 1229 * from external source 0 and route the output of this overlay to 1230 * channel 0 1231 */ 1232 mcde_configure_overlay(mcde, MCDE_OVERLAY_0, MCDE_EXTSRC_0, 1233 MCDE_CHANNEL_0, mode, format, cpp); 1234 1235 /* 1236 * Configure pixel-per-line and line-per-frame for channel 0 and then 1237 * route channel 0 to FIFO A 1238 */ 1239 mcde_configure_channel(mcde, MCDE_CHANNEL_0, MCDE_FIFO_A, mode); 1240 1241 if (mcde->dpi_output) { 1242 unsigned long lcd_freq; 1243 1244 /* Configure FIFO A to use DPI formatter 0 */ 1245 mcde_configure_fifo(mcde, MCDE_FIFO_A, MCDE_DPI_FORMATTER_0, 1246 fifo_wtrmrk); 1247 1248 /* Set up and enable the LCD clock */ 1249 lcd_freq = clk_round_rate(mcde->fifoa_clk, mode->clock * 1000); 1250 ret = clk_set_rate(mcde->fifoa_clk, lcd_freq); 1251 if (ret) 1252 dev_err(mcde->dev, "failed to set LCD clock rate %lu Hz\n", 1253 lcd_freq); 1254 ret = clk_prepare_enable(mcde->fifoa_clk); 1255 if (ret) { 1256 dev_err(mcde->dev, "failed to enable FIFO A DPI clock\n"); 1257 return; 1258 } 1259 dev_info(mcde->dev, "LCD FIFO A clk rate %lu Hz\n", 1260 clk_get_rate(mcde->fifoa_clk)); 1261 } else { 1262 /* Configure FIFO A to use DSI formatter 0 */ 1263 mcde_configure_fifo(mcde, MCDE_FIFO_A, MCDE_DSI_FORMATTER_0, 1264 fifo_wtrmrk); 1265 1266 /* 1267 * This brings up the DSI bridge which is tightly connected 1268 * to the MCDE DSI formatter. 1269 */ 1270 mcde_dsi_enable(mcde->bridge); 1271 1272 /* Configure the DSI formatter 0 for the DSI panel output */ 1273 mcde_configure_dsi_formatter(mcde, MCDE_DSI_FORMATTER_0, 1274 dsi_formatter_frame, dsi_pkt_size); 1275 } 1276 1277 switch (mcde->flow_mode) { 1278 case MCDE_COMMAND_TE_FLOW: 1279 case MCDE_COMMAND_BTA_TE_FLOW: 1280 case MCDE_VIDEO_TE_FLOW: 1281 /* We are using TE in some combination */ 1282 if (mode->flags & DRM_MODE_FLAG_NVSYNC) 1283 val = MCDE_VSCRC_VSPOL; 1284 else 1285 val = 0; 1286 writel(val, mcde->regs + MCDE_VSCRC0); 1287 /* Enable VSYNC capture on TE0 */ 1288 val = readl(mcde->regs + MCDE_CRC); 1289 val |= MCDE_CRC_SYCEN0; 1290 writel(val, mcde->regs + MCDE_CRC); 1291 break; 1292 default: 1293 /* No TE capture */ 1294 break; 1295 } 1296 1297 drm_crtc_vblank_on(crtc); 1298 1299 /* 1300 * If we're using oneshot mode we don't start the flow 1301 * until each time the display is given an update, and 1302 * then we disable it immediately after. For all other 1303 * modes (command or video) we start the FIFO flow 1304 * right here. This is necessary for the hardware to 1305 * behave right. 1306 */ 1307 if (mcde->flow_mode != MCDE_COMMAND_ONESHOT_FLOW) { 1308 mcde_enable_fifo(mcde, MCDE_FIFO_A); 1309 dev_dbg(mcde->dev, "started MCDE video FIFO flow\n"); 1310 } 1311 1312 /* Enable MCDE with automatic clock gating */ 1313 val = readl(mcde->regs + MCDE_CR); 1314 val |= MCDE_CR_MCDEEN | MCDE_CR_AUTOCLKG_EN; 1315 writel(val, mcde->regs + MCDE_CR); 1316 1317 dev_info(drm->dev, "MCDE display is enabled\n"); 1318 } 1319 1320 static void mcde_crtc_helper_atomic_disable(struct drm_crtc *crtc, 1321 struct drm_atomic_commit *commit) 1322 { 1323 struct drm_crtc_state *cstate = drm_atomic_get_new_crtc_state(commit, crtc); 1324 struct drm_device *drm = crtc->dev; 1325 struct mcde *mcde = to_mcde(drm); 1326 struct drm_pending_vblank_event *event; 1327 int ret; 1328 1329 drm_crtc_vblank_off(crtc); 1330 1331 /* Disable FIFO A flow */ 1332 mcde_disable_fifo(mcde, MCDE_FIFO_A, true); 1333 1334 if (mcde->dpi_output) { 1335 clk_disable_unprepare(mcde->fifoa_clk); 1336 } else { 1337 /* This disables the DSI bridge */ 1338 mcde_dsi_disable(mcde->bridge); 1339 } 1340 1341 event = cstate->event; 1342 if (event) { 1343 cstate->event = NULL; 1344 1345 spin_lock_irq(&crtc->dev->event_lock); 1346 drm_crtc_send_vblank_event(crtc, event); 1347 spin_unlock_irq(&crtc->dev->event_lock); 1348 } 1349 1350 ret = regulator_disable(mcde->epod); 1351 if (ret) 1352 dev_err(drm->dev, "can't disable EPOD regulator\n"); 1353 /* Make sure we are powered down (before we may power up again) */ 1354 usleep_range(50000, 70000); 1355 1356 dev_info(drm->dev, "MCDE display is disabled\n"); 1357 } 1358 1359 static void mcde_start_flow(struct mcde *mcde) 1360 { 1361 /* Request a TE ACK only in TE+BTA mode */ 1362 if (mcde->flow_mode == MCDE_COMMAND_BTA_TE_FLOW) 1363 mcde_dsi_te_request(mcde->mdsi); 1364 1365 /* Enable FIFO A flow */ 1366 mcde_enable_fifo(mcde, MCDE_FIFO_A); 1367 1368 /* 1369 * If oneshot mode is enabled, the flow will be disabled 1370 * when the TE0 IRQ arrives in the interrupt handler. Otherwise 1371 * updates are continuously streamed to the display after this 1372 * point. 1373 */ 1374 1375 if (mcde->flow_mode == MCDE_COMMAND_ONESHOT_FLOW) { 1376 /* Trigger a software sync out on channel 0 */ 1377 writel(MCDE_CHNLXSYNCHSW_SW_TRIG, 1378 mcde->regs + MCDE_CHNL0SYNCHSW); 1379 1380 /* 1381 * Disable FIFO A flow again: since we are using TE sync we 1382 * need to wait for the FIFO to drain before we continue 1383 * so repeated calls to this function will not cause a mess 1384 * in the hardware by pushing updates will updates are going 1385 * on already. 1386 */ 1387 mcde_disable_fifo(mcde, MCDE_FIFO_A, true); 1388 } 1389 1390 dev_dbg(mcde->dev, "started MCDE FIFO flow\n"); 1391 } 1392 1393 static void mcde_set_extsrc(struct mcde *mcde, u32 buffer_address) 1394 { 1395 /* Write bitmap base address to register */ 1396 writel(buffer_address, mcde->regs + MCDE_EXTSRCXA0); 1397 /* 1398 * Base address for next line this is probably only used 1399 * in interlace modes. 1400 */ 1401 writel(buffer_address + mcde->stride, mcde->regs + MCDE_EXTSRCXA1); 1402 } 1403 1404 static void mcde_plane_helper_atomic_update(struct drm_plane *plane, 1405 struct drm_atomic_commit *commit) 1406 { 1407 struct drm_plane_state *pstate = drm_atomic_get_new_plane_state(commit, plane); 1408 struct mcde *mcde = to_mcde(plane->dev); 1409 struct drm_framebuffer *fb = pstate->fb; 1410 1411 /* 1412 * We do not start sending framebuffer updates before the 1413 * display is enabled. Update events will however be dispatched 1414 * from the DRM core before the display is enabled. 1415 */ 1416 if (fb) { 1417 mcde_set_extsrc(mcde, drm_fb_dma_get_gem_addr(fb, pstate, 0)); 1418 dev_info_once(mcde->dev, "first update of display contents\n"); 1419 } else { 1420 /* 1421 * If an update is receieved before the MCDE is enabled 1422 * (before mcde_display_enable() is called) we can't really 1423 * do much with that buffer. 1424 */ 1425 dev_info(mcde->dev, "ignored a display update\n"); 1426 } 1427 } 1428 1429 static void mcde_crtc_helper_atomic_flush(struct drm_crtc *crtc, 1430 struct drm_atomic_commit *commit) 1431 { 1432 struct mcde *mcde = to_mcde(crtc->dev); 1433 struct drm_plane_state *plane_state = drm_atomic_get_new_plane_state(commit, &mcde->plane); 1434 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(commit, crtc); 1435 struct drm_pending_vblank_event *event = crtc_state->event; 1436 1437 /* 1438 * Handle any pending event first, we need to arm the vblank 1439 * interrupt before sending any update to the display so we don't 1440 * miss the interrupt. 1441 */ 1442 if (event) { 1443 crtc_state->event = NULL; 1444 1445 spin_lock_irq(&crtc->dev->event_lock); 1446 /* 1447 * Hardware must be on before we can arm any vblank event, 1448 * this is not a scanout controller where there is always 1449 * some periodic update going on, it is completely frozen 1450 * until we get an update. If MCDE output isn't yet enabled, 1451 * we just send a vblank dummy event back. 1452 */ 1453 if (crtc_state->active && drm_crtc_vblank_get(crtc) == 0) { 1454 dev_dbg(mcde->dev, "arm vblank event\n"); 1455 drm_crtc_arm_vblank_event(crtc, event); 1456 } else { 1457 dev_dbg(mcde->dev, "insert fake vblank event\n"); 1458 drm_crtc_send_vblank_event(crtc, event); 1459 } 1460 1461 spin_unlock_irq(&crtc->dev->event_lock); 1462 } 1463 1464 if (crtc_state->active && plane_state && plane_state->fb && mcde->flow_active == 0) 1465 mcde_start_flow(mcde); 1466 } 1467 1468 static int mcde_crtc_enable_vblank(struct drm_crtc *crtc) 1469 { 1470 struct drm_device *drm = crtc->dev; 1471 struct mcde *mcde = to_mcde(drm); 1472 u32 val; 1473 1474 /* Enable all VBLANK IRQs */ 1475 val = MCDE_PP_VCMPA | 1476 MCDE_PP_VCMPB | 1477 MCDE_PP_VSCC0 | 1478 MCDE_PP_VSCC1 | 1479 MCDE_PP_VCMPC0 | 1480 MCDE_PP_VCMPC1; 1481 writel(val, mcde->regs + MCDE_IMSCPP); 1482 1483 return 0; 1484 } 1485 1486 static void mcde_crtc_disable_vblank(struct drm_crtc *crtc) 1487 { 1488 struct drm_device *drm = crtc->dev; 1489 struct mcde *mcde = to_mcde(drm); 1490 1491 /* Disable all VBLANK IRQs */ 1492 writel(0, mcde->regs + MCDE_IMSCPP); 1493 /* Clear any pending IRQs */ 1494 writel(0xFFFFFFFF, mcde->regs + MCDE_RISPP); 1495 } 1496 1497 static int mcde_crtc_helper_atomic_check(struct drm_crtc *crtc, struct drm_atomic_commit *commit) 1498 { 1499 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(commit, crtc); 1500 int ret; 1501 1502 if (crtc_state->enable) { 1503 ret = drm_atomic_helper_check_crtc_primary_plane(crtc_state); 1504 if (ret) 1505 return ret; 1506 } 1507 1508 return drm_atomic_add_affected_planes(commit, crtc); 1509 } 1510 1511 static const struct drm_crtc_funcs mcde_crtc_funcs = { 1512 .atomic_create_state = drm_atomic_helper_crtc_create_state, 1513 .destroy = drm_crtc_cleanup, 1514 .set_config = drm_atomic_helper_set_config, 1515 .page_flip = drm_atomic_helper_page_flip, 1516 .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, 1517 .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, 1518 .enable_vblank = mcde_crtc_enable_vblank, 1519 .disable_vblank = mcde_crtc_disable_vblank, 1520 }; 1521 1522 static const struct drm_crtc_helper_funcs mcde_crtc_helper_funcs = { 1523 .atomic_check = mcde_crtc_helper_atomic_check, 1524 .atomic_enable = mcde_crtc_helper_atomic_enable, 1525 .atomic_disable = mcde_crtc_helper_atomic_disable, 1526 .atomic_flush = mcde_crtc_helper_atomic_flush, 1527 }; 1528 1529 static const struct drm_plane_funcs mcde_plane_funcs = { 1530 .update_plane = drm_atomic_helper_update_plane, 1531 .disable_plane = drm_atomic_helper_disable_plane, 1532 .atomic_create_state = drm_atomic_helper_plane_create_state, 1533 .destroy = drm_plane_cleanup, 1534 .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, 1535 .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, 1536 }; 1537 1538 static const struct drm_plane_helper_funcs mcde_plane_helper_funcs = { 1539 .prepare_fb = drm_gem_plane_helper_prepare_fb, 1540 .atomic_check = mcde_plane_helper_atomic_check, 1541 .atomic_update = mcde_plane_helper_atomic_update, 1542 }; 1543 1544 static const struct drm_encoder_funcs mcde_encoder_funcs = { 1545 .destroy = drm_encoder_cleanup, 1546 }; 1547 1548 int mcde_display_init(struct drm_device *drm) 1549 { 1550 struct mcde *mcde = to_mcde(drm); 1551 int ret; 1552 static const u32 formats[] = { 1553 DRM_FORMAT_ARGB8888, 1554 DRM_FORMAT_ABGR8888, 1555 DRM_FORMAT_XRGB8888, 1556 DRM_FORMAT_XBGR8888, 1557 DRM_FORMAT_RGB888, 1558 DRM_FORMAT_BGR888, 1559 DRM_FORMAT_ARGB4444, 1560 DRM_FORMAT_ABGR4444, 1561 DRM_FORMAT_XRGB4444, 1562 DRM_FORMAT_XBGR4444, 1563 /* These are actually IRGB1555 so intensity bit is lost */ 1564 DRM_FORMAT_XRGB1555, 1565 DRM_FORMAT_XBGR1555, 1566 DRM_FORMAT_RGB565, 1567 DRM_FORMAT_BGR565, 1568 DRM_FORMAT_YUV422, 1569 }; 1570 1571 ret = mcde_init_clock_divider(mcde); 1572 if (ret) 1573 return ret; 1574 1575 ret = drm_universal_plane_init(drm, &mcde->plane, 0, 1576 &mcde_plane_funcs, 1577 formats, ARRAY_SIZE(formats), 1578 NULL, DRM_PLANE_TYPE_PRIMARY, NULL); 1579 if (ret) 1580 return ret; 1581 1582 drm_plane_helper_add(&mcde->plane, &mcde_plane_helper_funcs); 1583 1584 ret = drm_crtc_init_with_planes(drm, &mcde->crtc, &mcde->plane, 1585 NULL, &mcde_crtc_funcs, NULL); 1586 if (ret) 1587 return ret; 1588 1589 drm_crtc_helper_add(&mcde->crtc, &mcde_crtc_helper_funcs); 1590 1591 ret = drm_encoder_init(drm, &mcde->encoder, &mcde_encoder_funcs, 1592 DRM_MODE_ENCODER_NONE, NULL); 1593 if (ret) 1594 return ret; 1595 1596 mcde->encoder.possible_crtcs = drm_crtc_mask(&mcde->crtc); 1597 1598 return 0; 1599 } 1600 EXPORT_SYMBOL_GPL(mcde_display_init); 1601