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