Loading...
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
28enum mcde_fifo {
29 MCDE_FIFO_A,
30 MCDE_FIFO_B,
31 /* TODO: implement FIFO C0 and FIFO C1 */
32};
33
34enum mcde_channel {
35 MCDE_CHANNEL_0 = 0,
36 MCDE_CHANNEL_1,
37 MCDE_CHANNEL_2,
38 MCDE_CHANNEL_3,
39};
40
41enum 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
54enum 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
63enum 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
74void 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
146void 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
159static 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
196static 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
338static 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
490static 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
630static 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
748static 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
844static 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
870static 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 */
915static 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
958static 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
973static 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
1070static 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
1151static 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
1300static 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
1338static 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
1372static 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
1383static 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
1445static 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
1464static 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
1476static 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
1485int 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}
1522EXPORT_SYMBOL_GPL(mcde_display_init);
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
11#include <drm/drm_device.h>
12#include <drm/drm_fb_cma_helper.h>
13#include <drm/drm_fourcc.h>
14#include <drm/drm_gem_cma_helper.h>
15#include <drm/drm_gem_framebuffer_helper.h>
16#include <drm/drm_mipi_dsi.h>
17#include <drm/drm_simple_kms_helper.h>
18#include <drm/drm_vblank.h>
19#include <video/mipi_display.h>
20
21#include "mcde_drm.h"
22#include "mcde_display_regs.h"
23
24enum mcde_fifo {
25 MCDE_FIFO_A,
26 MCDE_FIFO_B,
27 /* TODO: implement FIFO C0 and FIFO C1 */
28};
29
30enum mcde_channel {
31 MCDE_CHANNEL_0 = 0,
32 MCDE_CHANNEL_1,
33 MCDE_CHANNEL_2,
34 MCDE_CHANNEL_3,
35};
36
37enum mcde_extsrc {
38 MCDE_EXTSRC_0 = 0,
39 MCDE_EXTSRC_1,
40 MCDE_EXTSRC_2,
41 MCDE_EXTSRC_3,
42 MCDE_EXTSRC_4,
43 MCDE_EXTSRC_5,
44 MCDE_EXTSRC_6,
45 MCDE_EXTSRC_7,
46 MCDE_EXTSRC_8,
47 MCDE_EXTSRC_9,
48};
49
50enum mcde_overlay {
51 MCDE_OVERLAY_0 = 0,
52 MCDE_OVERLAY_1,
53 MCDE_OVERLAY_2,
54 MCDE_OVERLAY_3,
55 MCDE_OVERLAY_4,
56 MCDE_OVERLAY_5,
57};
58
59enum mcde_dsi_formatter {
60 MCDE_DSI_FORMATTER_0 = 0,
61 MCDE_DSI_FORMATTER_1,
62 MCDE_DSI_FORMATTER_2,
63};
64
65void mcde_display_irq(struct mcde *mcde)
66{
67 u32 mispp, misovl, mischnl;
68 bool vblank = false;
69
70 /* Handle display IRQs */
71 mispp = readl(mcde->regs + MCDE_MISPP);
72 misovl = readl(mcde->regs + MCDE_MISOVL);
73 mischnl = readl(mcde->regs + MCDE_MISCHNL);
74
75 /*
76 * Handle IRQs from the DSI link. All IRQs from the DSI links
77 * are just latched onto the MCDE IRQ line, so we need to traverse
78 * any active DSI masters and check if an IRQ is originating from
79 * them.
80 *
81 * TODO: Currently only one DSI link is supported.
82 */
83 if (mcde_dsi_irq(mcde->mdsi)) {
84 u32 val;
85
86 /*
87 * In oneshot mode we do not send continuous updates
88 * to the display, instead we only push out updates when
89 * the update function is called, then we disable the
90 * flow on the channel once we get the TE IRQ.
91 */
92 if (mcde->oneshot_mode) {
93 spin_lock(&mcde->flow_lock);
94 if (--mcde->flow_active == 0) {
95 dev_dbg(mcde->dev, "TE0 IRQ\n");
96 /* Disable FIFO A flow */
97 val = readl(mcde->regs + MCDE_CRA0);
98 val &= ~MCDE_CRX0_FLOEN;
99 writel(val, mcde->regs + MCDE_CRA0);
100 }
101 spin_unlock(&mcde->flow_lock);
102 }
103 }
104
105 /* Vblank from one of the channels */
106 if (mispp & MCDE_PP_VCMPA) {
107 dev_dbg(mcde->dev, "chnl A vblank IRQ\n");
108 vblank = true;
109 }
110 if (mispp & MCDE_PP_VCMPB) {
111 dev_dbg(mcde->dev, "chnl B vblank IRQ\n");
112 vblank = true;
113 }
114 if (mispp & MCDE_PP_VCMPC0)
115 dev_dbg(mcde->dev, "chnl C0 vblank IRQ\n");
116 if (mispp & MCDE_PP_VCMPC1)
117 dev_dbg(mcde->dev, "chnl C1 vblank IRQ\n");
118 if (mispp & MCDE_PP_VSCC0)
119 dev_dbg(mcde->dev, "chnl C0 TE IRQ\n");
120 if (mispp & MCDE_PP_VSCC1)
121 dev_dbg(mcde->dev, "chnl C1 TE IRQ\n");
122 writel(mispp, mcde->regs + MCDE_RISPP);
123
124 if (vblank)
125 drm_crtc_handle_vblank(&mcde->pipe.crtc);
126
127 if (misovl)
128 dev_info(mcde->dev, "some stray overlay IRQ %08x\n", misovl);
129 writel(misovl, mcde->regs + MCDE_RISOVL);
130
131 if (mischnl)
132 dev_info(mcde->dev, "some stray channel error IRQ %08x\n",
133 mischnl);
134 writel(mischnl, mcde->regs + MCDE_RISCHNL);
135}
136
137void mcde_display_disable_irqs(struct mcde *mcde)
138{
139 /* Disable all IRQs */
140 writel(0, mcde->regs + MCDE_IMSCPP);
141 writel(0, mcde->regs + MCDE_IMSCOVL);
142 writel(0, mcde->regs + MCDE_IMSCCHNL);
143
144 /* Clear any pending IRQs */
145 writel(0xFFFFFFFF, mcde->regs + MCDE_RISPP);
146 writel(0xFFFFFFFF, mcde->regs + MCDE_RISOVL);
147 writel(0xFFFFFFFF, mcde->regs + MCDE_RISCHNL);
148}
149
150static int mcde_display_check(struct drm_simple_display_pipe *pipe,
151 struct drm_plane_state *pstate,
152 struct drm_crtc_state *cstate)
153{
154 const struct drm_display_mode *mode = &cstate->mode;
155 struct drm_framebuffer *old_fb = pipe->plane.state->fb;
156 struct drm_framebuffer *fb = pstate->fb;
157
158 if (fb) {
159 u32 offset = drm_fb_cma_get_gem_addr(fb, pstate, 0);
160
161 /* FB base address must be dword aligned. */
162 if (offset & 3) {
163 DRM_DEBUG_KMS("FB not 32-bit aligned\n");
164 return -EINVAL;
165 }
166
167 /*
168 * There's no pitch register, the mode's hdisplay
169 * controls this.
170 */
171 if (fb->pitches[0] != mode->hdisplay * fb->format->cpp[0]) {
172 DRM_DEBUG_KMS("can't handle pitches\n");
173 return -EINVAL;
174 }
175
176 /*
177 * We can't change the FB format in a flicker-free
178 * manner (and only update it during CRTC enable).
179 */
180 if (old_fb && old_fb->format != fb->format)
181 cstate->mode_changed = true;
182 }
183
184 return 0;
185}
186
187static int mcde_configure_extsrc(struct mcde *mcde, enum mcde_extsrc src,
188 u32 format)
189{
190 u32 val;
191 u32 conf;
192 u32 cr;
193
194 switch (src) {
195 case MCDE_EXTSRC_0:
196 conf = MCDE_EXTSRC0CONF;
197 cr = MCDE_EXTSRC0CR;
198 break;
199 case MCDE_EXTSRC_1:
200 conf = MCDE_EXTSRC1CONF;
201 cr = MCDE_EXTSRC1CR;
202 break;
203 case MCDE_EXTSRC_2:
204 conf = MCDE_EXTSRC2CONF;
205 cr = MCDE_EXTSRC2CR;
206 break;
207 case MCDE_EXTSRC_3:
208 conf = MCDE_EXTSRC3CONF;
209 cr = MCDE_EXTSRC3CR;
210 break;
211 case MCDE_EXTSRC_4:
212 conf = MCDE_EXTSRC4CONF;
213 cr = MCDE_EXTSRC4CR;
214 break;
215 case MCDE_EXTSRC_5:
216 conf = MCDE_EXTSRC5CONF;
217 cr = MCDE_EXTSRC5CR;
218 break;
219 case MCDE_EXTSRC_6:
220 conf = MCDE_EXTSRC6CONF;
221 cr = MCDE_EXTSRC6CR;
222 break;
223 case MCDE_EXTSRC_7:
224 conf = MCDE_EXTSRC7CONF;
225 cr = MCDE_EXTSRC7CR;
226 break;
227 case MCDE_EXTSRC_8:
228 conf = MCDE_EXTSRC8CONF;
229 cr = MCDE_EXTSRC8CR;
230 break;
231 case MCDE_EXTSRC_9:
232 conf = MCDE_EXTSRC9CONF;
233 cr = MCDE_EXTSRC9CR;
234 break;
235 }
236
237 /*
238 * Configure external source 0 one buffer (buffer 0)
239 * primary overlay ID 0.
240 * From mcde_hw.c ovly_update_registers() in the vendor tree
241 */
242 val = 0 << MCDE_EXTSRCXCONF_BUF_ID_SHIFT;
243 val |= 1 << MCDE_EXTSRCXCONF_BUF_NB_SHIFT;
244 val |= 0 << MCDE_EXTSRCXCONF_PRI_OVLID_SHIFT;
245 /*
246 * MCDE has inverse semantics from DRM on RBG/BGR which is why
247 * all the modes are inversed here.
248 */
249 switch (format) {
250 case DRM_FORMAT_ARGB8888:
251 val |= MCDE_EXTSRCXCONF_BPP_ARGB8888 <<
252 MCDE_EXTSRCXCONF_BPP_SHIFT;
253 val |= MCDE_EXTSRCXCONF_BGR;
254 break;
255 case DRM_FORMAT_ABGR8888:
256 val |= MCDE_EXTSRCXCONF_BPP_ARGB8888 <<
257 MCDE_EXTSRCXCONF_BPP_SHIFT;
258 break;
259 case DRM_FORMAT_XRGB8888:
260 val |= MCDE_EXTSRCXCONF_BPP_XRGB8888 <<
261 MCDE_EXTSRCXCONF_BPP_SHIFT;
262 val |= MCDE_EXTSRCXCONF_BGR;
263 break;
264 case DRM_FORMAT_XBGR8888:
265 val |= MCDE_EXTSRCXCONF_BPP_XRGB8888 <<
266 MCDE_EXTSRCXCONF_BPP_SHIFT;
267 break;
268 case DRM_FORMAT_RGB888:
269 val |= MCDE_EXTSRCXCONF_BPP_RGB888 <<
270 MCDE_EXTSRCXCONF_BPP_SHIFT;
271 val |= MCDE_EXTSRCXCONF_BGR;
272 break;
273 case DRM_FORMAT_BGR888:
274 val |= MCDE_EXTSRCXCONF_BPP_RGB888 <<
275 MCDE_EXTSRCXCONF_BPP_SHIFT;
276 break;
277 case DRM_FORMAT_ARGB4444:
278 val |= MCDE_EXTSRCXCONF_BPP_ARGB4444 <<
279 MCDE_EXTSRCXCONF_BPP_SHIFT;
280 val |= MCDE_EXTSRCXCONF_BGR;
281 break;
282 case DRM_FORMAT_ABGR4444:
283 val |= MCDE_EXTSRCXCONF_BPP_ARGB4444 <<
284 MCDE_EXTSRCXCONF_BPP_SHIFT;
285 break;
286 case DRM_FORMAT_XRGB4444:
287 val |= MCDE_EXTSRCXCONF_BPP_RGB444 <<
288 MCDE_EXTSRCXCONF_BPP_SHIFT;
289 val |= MCDE_EXTSRCXCONF_BGR;
290 break;
291 case DRM_FORMAT_XBGR4444:
292 val |= MCDE_EXTSRCXCONF_BPP_RGB444 <<
293 MCDE_EXTSRCXCONF_BPP_SHIFT;
294 break;
295 case DRM_FORMAT_XRGB1555:
296 val |= MCDE_EXTSRCXCONF_BPP_IRGB1555 <<
297 MCDE_EXTSRCXCONF_BPP_SHIFT;
298 val |= MCDE_EXTSRCXCONF_BGR;
299 break;
300 case DRM_FORMAT_XBGR1555:
301 val |= MCDE_EXTSRCXCONF_BPP_IRGB1555 <<
302 MCDE_EXTSRCXCONF_BPP_SHIFT;
303 break;
304 case DRM_FORMAT_RGB565:
305 val |= MCDE_EXTSRCXCONF_BPP_RGB565 <<
306 MCDE_EXTSRCXCONF_BPP_SHIFT;
307 val |= MCDE_EXTSRCXCONF_BGR;
308 break;
309 case DRM_FORMAT_BGR565:
310 val |= MCDE_EXTSRCXCONF_BPP_RGB565 <<
311 MCDE_EXTSRCXCONF_BPP_SHIFT;
312 break;
313 case DRM_FORMAT_YUV422:
314 val |= MCDE_EXTSRCXCONF_BPP_YCBCR422 <<
315 MCDE_EXTSRCXCONF_BPP_SHIFT;
316 break;
317 default:
318 dev_err(mcde->dev, "Unknown pixel format 0x%08x\n",
319 format);
320 return -EINVAL;
321 }
322 writel(val, mcde->regs + conf);
323
324 /* Software select, primary */
325 val = MCDE_EXTSRCXCR_SEL_MOD_SOFTWARE_SEL;
326 val |= MCDE_EXTSRCXCR_MULTIOVL_CTRL_PRIMARY;
327 writel(val, mcde->regs + cr);
328
329 return 0;
330}
331
332static void mcde_configure_overlay(struct mcde *mcde, enum mcde_overlay ovl,
333 enum mcde_extsrc src,
334 enum mcde_channel ch,
335 const struct drm_display_mode *mode,
336 u32 format)
337{
338 u32 val;
339 u32 conf1;
340 u32 conf2;
341 u32 crop;
342 u32 ljinc;
343 u32 cr;
344 u32 comp;
345
346 switch (ovl) {
347 case MCDE_OVERLAY_0:
348 conf1 = MCDE_OVL0CONF;
349 conf2 = MCDE_OVL0CONF2;
350 crop = MCDE_OVL0CROP;
351 ljinc = MCDE_OVL0LJINC;
352 cr = MCDE_OVL0CR;
353 comp = MCDE_OVL0COMP;
354 break;
355 case MCDE_OVERLAY_1:
356 conf1 = MCDE_OVL1CONF;
357 conf2 = MCDE_OVL1CONF2;
358 crop = MCDE_OVL1CROP;
359 ljinc = MCDE_OVL1LJINC;
360 cr = MCDE_OVL1CR;
361 comp = MCDE_OVL1COMP;
362 break;
363 case MCDE_OVERLAY_2:
364 conf1 = MCDE_OVL2CONF;
365 conf2 = MCDE_OVL2CONF2;
366 crop = MCDE_OVL2CROP;
367 ljinc = MCDE_OVL2LJINC;
368 cr = MCDE_OVL2CR;
369 comp = MCDE_OVL2COMP;
370 break;
371 case MCDE_OVERLAY_3:
372 conf1 = MCDE_OVL3CONF;
373 conf2 = MCDE_OVL3CONF2;
374 crop = MCDE_OVL3CROP;
375 ljinc = MCDE_OVL3LJINC;
376 cr = MCDE_OVL3CR;
377 comp = MCDE_OVL3COMP;
378 break;
379 case MCDE_OVERLAY_4:
380 conf1 = MCDE_OVL4CONF;
381 conf2 = MCDE_OVL4CONF2;
382 crop = MCDE_OVL4CROP;
383 ljinc = MCDE_OVL4LJINC;
384 cr = MCDE_OVL4CR;
385 comp = MCDE_OVL4COMP;
386 break;
387 case MCDE_OVERLAY_5:
388 conf1 = MCDE_OVL5CONF;
389 conf2 = MCDE_OVL5CONF2;
390 crop = MCDE_OVL5CROP;
391 ljinc = MCDE_OVL5LJINC;
392 cr = MCDE_OVL5CR;
393 comp = MCDE_OVL5COMP;
394 break;
395 }
396
397 val = mode->hdisplay << MCDE_OVLXCONF_PPL_SHIFT;
398 val |= mode->vdisplay << MCDE_OVLXCONF_LPF_SHIFT;
399 /* Use external source 0 that we just configured */
400 val |= src << MCDE_OVLXCONF_EXTSRC_ID_SHIFT;
401 writel(val, mcde->regs + conf1);
402
403 val = MCDE_OVLXCONF2_BP_PER_PIXEL_ALPHA;
404 val |= 0xff << MCDE_OVLXCONF2_ALPHAVALUE_SHIFT;
405 /* OPQ: overlay is opaque */
406 switch (format) {
407 case DRM_FORMAT_ARGB8888:
408 case DRM_FORMAT_ABGR8888:
409 case DRM_FORMAT_ARGB4444:
410 case DRM_FORMAT_ABGR4444:
411 case DRM_FORMAT_XRGB1555:
412 case DRM_FORMAT_XBGR1555:
413 /* No OPQ */
414 break;
415 case DRM_FORMAT_XRGB8888:
416 case DRM_FORMAT_XBGR8888:
417 case DRM_FORMAT_RGB888:
418 case DRM_FORMAT_BGR888:
419 case DRM_FORMAT_RGB565:
420 case DRM_FORMAT_BGR565:
421 case DRM_FORMAT_YUV422:
422 val |= MCDE_OVLXCONF2_OPQ;
423 break;
424 default:
425 dev_err(mcde->dev, "Unknown pixel format 0x%08x\n",
426 format);
427 break;
428 }
429 /* The default watermark level for overlay 0 is 48 */
430 val |= 48 << MCDE_OVLXCONF2_PIXELFETCHERWATERMARKLEVEL_SHIFT;
431 writel(val, mcde->regs + conf2);
432
433 /* Number of bytes to fetch per line */
434 writel(mcde->stride, mcde->regs + ljinc);
435 /* No cropping */
436 writel(0, mcde->regs + crop);
437
438 /* Set up overlay control register */
439 val = MCDE_OVLXCR_OVLEN;
440 val |= MCDE_OVLXCR_COLCCTRL_DISABLED;
441 val |= MCDE_OVLXCR_BURSTSIZE_8W <<
442 MCDE_OVLXCR_BURSTSIZE_SHIFT;
443 val |= MCDE_OVLXCR_MAXOUTSTANDING_8_REQ <<
444 MCDE_OVLXCR_MAXOUTSTANDING_SHIFT;
445 /* Not using rotation but set it up anyways */
446 val |= MCDE_OVLXCR_ROTBURSTSIZE_8W <<
447 MCDE_OVLXCR_ROTBURSTSIZE_SHIFT;
448 writel(val, mcde->regs + cr);
449
450 /*
451 * Set up the overlay compositor to route the overlay out to
452 * the desired channel
453 */
454 val = ch << MCDE_OVLXCOMP_CH_ID_SHIFT;
455 writel(val, mcde->regs + comp);
456}
457
458static void mcde_configure_channel(struct mcde *mcde, enum mcde_channel ch,
459 enum mcde_fifo fifo,
460 const struct drm_display_mode *mode)
461{
462 u32 val;
463 u32 conf;
464 u32 sync;
465 u32 stat;
466 u32 bgcol;
467 u32 mux;
468
469 switch (ch) {
470 case MCDE_CHANNEL_0:
471 conf = MCDE_CHNL0CONF;
472 sync = MCDE_CHNL0SYNCHMOD;
473 stat = MCDE_CHNL0STAT;
474 bgcol = MCDE_CHNL0BCKGNDCOL;
475 mux = MCDE_CHNL0MUXING;
476 break;
477 case MCDE_CHANNEL_1:
478 conf = MCDE_CHNL1CONF;
479 sync = MCDE_CHNL1SYNCHMOD;
480 stat = MCDE_CHNL1STAT;
481 bgcol = MCDE_CHNL1BCKGNDCOL;
482 mux = MCDE_CHNL1MUXING;
483 break;
484 case MCDE_CHANNEL_2:
485 conf = MCDE_CHNL2CONF;
486 sync = MCDE_CHNL2SYNCHMOD;
487 stat = MCDE_CHNL2STAT;
488 bgcol = MCDE_CHNL2BCKGNDCOL;
489 mux = MCDE_CHNL2MUXING;
490 break;
491 case MCDE_CHANNEL_3:
492 conf = MCDE_CHNL3CONF;
493 sync = MCDE_CHNL3SYNCHMOD;
494 stat = MCDE_CHNL3STAT;
495 bgcol = MCDE_CHNL3BCKGNDCOL;
496 mux = MCDE_CHNL3MUXING;
497 return;
498 }
499
500 /* Set up channel 0 sync (based on chnl_update_registers()) */
501 if (mcde->te_sync) {
502 /*
503 * Turn on hardware TE0 synchronization
504 */
505 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_HARDWARE
506 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
507 val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_TE0
508 << MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT;
509 } else {
510 /*
511 * Set up sync source to software, out sync formatter
512 * Code mostly from mcde_hw.c chnl_update_registers()
513 */
514 val = MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SOFTWARE
515 << MCDE_CHNLXSYNCHMOD_SRC_SYNCH_SHIFT;
516 val |= MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_FORMATTER
517 << MCDE_CHNLXSYNCHMOD_OUT_SYNCH_SRC_SHIFT;
518 }
519 writel(val, mcde->regs + sync);
520
521 /* Set up pixels per line and lines per frame */
522 val = (mode->hdisplay - 1) << MCDE_CHNLXCONF_PPL_SHIFT;
523 val |= (mode->vdisplay - 1) << MCDE_CHNLXCONF_LPF_SHIFT;
524 writel(val, mcde->regs + conf);
525
526 /*
527 * Normalize color conversion:
528 * black background, OLED conversion disable on channel
529 */
530 val = MCDE_CHNLXSTAT_CHNLBLBCKGND_EN |
531 MCDE_CHNLXSTAT_CHNLRD;
532 writel(val, mcde->regs + stat);
533 writel(0, mcde->regs + bgcol);
534
535 /* Set up muxing: connect the channel to the desired FIFO */
536 switch (fifo) {
537 case MCDE_FIFO_A:
538 writel(MCDE_CHNLXMUXING_FIFO_ID_FIFO_A,
539 mcde->regs + mux);
540 break;
541 case MCDE_FIFO_B:
542 writel(MCDE_CHNLXMUXING_FIFO_ID_FIFO_B,
543 mcde->regs + mux);
544 break;
545 }
546}
547
548static void mcde_configure_fifo(struct mcde *mcde, enum mcde_fifo fifo,
549 enum mcde_dsi_formatter fmt,
550 int fifo_wtrmrk)
551{
552 u32 val;
553 u32 ctrl;
554 u32 cr0, cr1;
555
556 switch (fifo) {
557 case MCDE_FIFO_A:
558 ctrl = MCDE_CTRLA;
559 cr0 = MCDE_CRA0;
560 cr1 = MCDE_CRA1;
561 break;
562 case MCDE_FIFO_B:
563 ctrl = MCDE_CTRLB;
564 cr0 = MCDE_CRB0;
565 cr1 = MCDE_CRB1;
566 break;
567 }
568
569 val = fifo_wtrmrk << MCDE_CTRLX_FIFOWTRMRK_SHIFT;
570 /* We only support DSI formatting for now */
571 val |= MCDE_CTRLX_FORMTYPE_DSI <<
572 MCDE_CTRLX_FORMTYPE_SHIFT;
573
574 /* Select the formatter to use for this FIFO */
575 val |= fmt << MCDE_CTRLX_FORMID_SHIFT;
576 writel(val, mcde->regs + ctrl);
577
578 /* Blend source with Alpha 0xff on FIFO */
579 val = MCDE_CRX0_BLENDEN |
580 0xff << MCDE_CRX0_ALPHABLEND_SHIFT;
581 writel(val, mcde->regs + cr0);
582
583 /* Set-up from mcde_fmtr_dsi.c, fmtr_dsi_enable_video() */
584
585 /* Use the MCDE clock for this FIFO */
586 val = MCDE_CRX1_CLKSEL_MCDECLK << MCDE_CRX1_CLKSEL_SHIFT;
587
588 /* TODO: when adding DPI support add OUTBPP etc here */
589 writel(val, mcde->regs + cr1);
590};
591
592static void mcde_configure_dsi_formatter(struct mcde *mcde,
593 enum mcde_dsi_formatter fmt,
594 u32 formatter_frame,
595 int pkt_size)
596{
597 u32 val;
598 u32 conf0;
599 u32 frame;
600 u32 pkt;
601 u32 sync;
602 u32 cmdw;
603 u32 delay0, delay1;
604
605 switch (fmt) {
606 case MCDE_DSI_FORMATTER_0:
607 conf0 = MCDE_DSIVID0CONF0;
608 frame = MCDE_DSIVID0FRAME;
609 pkt = MCDE_DSIVID0PKT;
610 sync = MCDE_DSIVID0SYNC;
611 cmdw = MCDE_DSIVID0CMDW;
612 delay0 = MCDE_DSIVID0DELAY0;
613 delay1 = MCDE_DSIVID0DELAY1;
614 break;
615 case MCDE_DSI_FORMATTER_1:
616 conf0 = MCDE_DSIVID1CONF0;
617 frame = MCDE_DSIVID1FRAME;
618 pkt = MCDE_DSIVID1PKT;
619 sync = MCDE_DSIVID1SYNC;
620 cmdw = MCDE_DSIVID1CMDW;
621 delay0 = MCDE_DSIVID1DELAY0;
622 delay1 = MCDE_DSIVID1DELAY1;
623 break;
624 case MCDE_DSI_FORMATTER_2:
625 conf0 = MCDE_DSIVID2CONF0;
626 frame = MCDE_DSIVID2FRAME;
627 pkt = MCDE_DSIVID2PKT;
628 sync = MCDE_DSIVID2SYNC;
629 cmdw = MCDE_DSIVID2CMDW;
630 delay0 = MCDE_DSIVID2DELAY0;
631 delay1 = MCDE_DSIVID2DELAY1;
632 break;
633 }
634
635 /*
636 * Enable formatter
637 * 8 bit commands and DCS commands (notgen = not generic)
638 */
639 val = MCDE_DSICONF0_CMD8 | MCDE_DSICONF0_DCSVID_NOTGEN;
640 if (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO)
641 val |= MCDE_DSICONF0_VID_MODE_VID;
642 switch (mcde->mdsi->format) {
643 case MIPI_DSI_FMT_RGB888:
644 val |= MCDE_DSICONF0_PACKING_RGB888 <<
645 MCDE_DSICONF0_PACKING_SHIFT;
646 break;
647 case MIPI_DSI_FMT_RGB666:
648 val |= MCDE_DSICONF0_PACKING_RGB666 <<
649 MCDE_DSICONF0_PACKING_SHIFT;
650 break;
651 case MIPI_DSI_FMT_RGB666_PACKED:
652 val |= MCDE_DSICONF0_PACKING_RGB666_PACKED <<
653 MCDE_DSICONF0_PACKING_SHIFT;
654 break;
655 case MIPI_DSI_FMT_RGB565:
656 val |= MCDE_DSICONF0_PACKING_RGB565 <<
657 MCDE_DSICONF0_PACKING_SHIFT;
658 break;
659 default:
660 dev_err(mcde->dev, "unknown DSI format\n");
661 return;
662 }
663 writel(val, mcde->regs + conf0);
664
665 writel(formatter_frame, mcde->regs + frame);
666 writel(pkt_size, mcde->regs + pkt);
667 writel(0, mcde->regs + sync);
668 /* Define the MIPI command: we want to write into display memory */
669 val = MIPI_DCS_WRITE_MEMORY_CONTINUE <<
670 MCDE_DSIVIDXCMDW_CMDW_CONTINUE_SHIFT;
671 val |= MIPI_DCS_WRITE_MEMORY_START <<
672 MCDE_DSIVIDXCMDW_CMDW_START_SHIFT;
673 writel(val, mcde->regs + cmdw);
674
675 /*
676 * FIXME: the vendor driver has some hack around this value in
677 * CMD mode with autotrig.
678 */
679 writel(0, mcde->regs + delay0);
680 writel(0, mcde->regs + delay1);
681}
682
683static void mcde_enable_fifo(struct mcde *mcde, enum mcde_fifo fifo)
684{
685 u32 val;
686 u32 cr;
687
688 switch (fifo) {
689 case MCDE_FIFO_A:
690 cr = MCDE_CRA0;
691 break;
692 case MCDE_FIFO_B:
693 cr = MCDE_CRB0;
694 break;
695 default:
696 dev_err(mcde->dev, "cannot enable FIFO %c\n",
697 'A' + fifo);
698 return;
699 }
700
701 spin_lock(&mcde->flow_lock);
702 val = readl(mcde->regs + cr);
703 val |= MCDE_CRX0_FLOEN;
704 writel(val, mcde->regs + cr);
705 mcde->flow_active++;
706 spin_unlock(&mcde->flow_lock);
707}
708
709static void mcde_disable_fifo(struct mcde *mcde, enum mcde_fifo fifo,
710 bool wait_for_drain)
711{
712 int timeout = 100;
713 u32 val;
714 u32 cr;
715
716 switch (fifo) {
717 case MCDE_FIFO_A:
718 cr = MCDE_CRA0;
719 break;
720 case MCDE_FIFO_B:
721 cr = MCDE_CRB0;
722 break;
723 default:
724 dev_err(mcde->dev, "cannot disable FIFO %c\n",
725 'A' + fifo);
726 return;
727 }
728
729 spin_lock(&mcde->flow_lock);
730 val = readl(mcde->regs + cr);
731 val &= ~MCDE_CRX0_FLOEN;
732 writel(val, mcde->regs + cr);
733 mcde->flow_active = 0;
734 spin_unlock(&mcde->flow_lock);
735
736 if (!wait_for_drain)
737 return;
738
739 /* Check that we really drained and stopped the flow */
740 while (readl(mcde->regs + cr) & MCDE_CRX0_FLOEN) {
741 usleep_range(1000, 1500);
742 if (!--timeout) {
743 dev_err(mcde->dev,
744 "FIFO timeout while clearing FIFO %c\n",
745 'A' + fifo);
746 return;
747 }
748 }
749}
750
751/*
752 * This drains a pipe i.e. a FIFO connected to a certain channel
753 */
754static void mcde_drain_pipe(struct mcde *mcde, enum mcde_fifo fifo,
755 enum mcde_channel ch)
756{
757 u32 val;
758 u32 ctrl;
759 u32 synsw;
760
761 switch (fifo) {
762 case MCDE_FIFO_A:
763 ctrl = MCDE_CTRLA;
764 break;
765 case MCDE_FIFO_B:
766 ctrl = MCDE_CTRLB;
767 break;
768 }
769
770 switch (ch) {
771 case MCDE_CHANNEL_0:
772 synsw = MCDE_CHNL0SYNCHSW;
773 break;
774 case MCDE_CHANNEL_1:
775 synsw = MCDE_CHNL1SYNCHSW;
776 break;
777 case MCDE_CHANNEL_2:
778 synsw = MCDE_CHNL2SYNCHSW;
779 break;
780 case MCDE_CHANNEL_3:
781 synsw = MCDE_CHNL3SYNCHSW;
782 return;
783 }
784
785 val = readl(mcde->regs + ctrl);
786 if (!(val & MCDE_CTRLX_FIFOEMPTY)) {
787 dev_err(mcde->dev, "Channel A FIFO not empty (handover)\n");
788 /* Attempt to clear the FIFO */
789 mcde_enable_fifo(mcde, fifo);
790 /* Trigger a software sync out on respective channel (0-3) */
791 writel(MCDE_CHNLXSYNCHSW_SW_TRIG, mcde->regs + synsw);
792 /* Disable FIFO A flow again */
793 mcde_disable_fifo(mcde, fifo, true);
794 }
795}
796
797static int mcde_dsi_get_pkt_div(int ppl, int fifo_size)
798{
799 /*
800 * DSI command mode line packets should be split into an even number of
801 * packets smaller than or equal to the fifo size.
802 */
803 int div;
804 const int max_div = DIV_ROUND_UP(MCDE_MAX_WIDTH, fifo_size);
805
806 for (div = 1; div < max_div; div++)
807 if (ppl % div == 0 && ppl / div <= fifo_size)
808 return div;
809 return 1;
810}
811
812static void mcde_display_enable(struct drm_simple_display_pipe *pipe,
813 struct drm_crtc_state *cstate,
814 struct drm_plane_state *plane_state)
815{
816 struct drm_crtc *crtc = &pipe->crtc;
817 struct drm_plane *plane = &pipe->plane;
818 struct drm_device *drm = crtc->dev;
819 struct mcde *mcde = drm->dev_private;
820 const struct drm_display_mode *mode = &cstate->mode;
821 struct drm_framebuffer *fb = plane->state->fb;
822 u32 format = fb->format->format;
823 u32 formatter_ppl = mode->hdisplay; /* pixels per line */
824 u32 formatter_lpf = mode->vdisplay; /* lines per frame */
825 int pkt_size, fifo_wtrmrk;
826 int cpp = fb->format->cpp[0];
827 int formatter_cpp;
828 struct drm_format_name_buf tmp;
829 u32 formatter_frame;
830 u32 pkt_div;
831 u32 val;
832
833 dev_info(drm->dev, "enable MCDE, %d x %d format %s\n",
834 mode->hdisplay, mode->vdisplay,
835 drm_get_format_name(format, &tmp));
836 if (!mcde->mdsi) {
837 /* TODO: deal with this for non-DSI output */
838 dev_err(drm->dev, "no DSI master attached!\n");
839 return;
840 }
841
842 dev_info(drm->dev, "output in %s mode, format %dbpp\n",
843 (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) ?
844 "VIDEO" : "CMD",
845 mipi_dsi_pixel_format_to_bpp(mcde->mdsi->format));
846 formatter_cpp =
847 mipi_dsi_pixel_format_to_bpp(mcde->mdsi->format) / 8;
848 dev_info(drm->dev, "overlay CPP %d bytes, DSI CPP %d bytes\n",
849 cpp,
850 formatter_cpp);
851
852 /* Calculations from mcde_fmtr_dsi.c, fmtr_dsi_enable_video() */
853
854 /*
855 * Set up FIFO A watermark level:
856 * 128 for LCD 32bpp video mode
857 * 48 for LCD 32bpp command mode
858 * 128 for LCD 16bpp video mode
859 * 64 for LCD 16bpp command mode
860 * 128 for HDMI 32bpp
861 * 192 for HDMI 16bpp
862 */
863 fifo_wtrmrk = mode->hdisplay;
864 if (mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO) {
865 fifo_wtrmrk = min(fifo_wtrmrk, 128);
866 pkt_div = 1;
867 } else {
868 fifo_wtrmrk = min(fifo_wtrmrk, 48);
869 /* The FIFO is 640 entries deep on this v3 hardware */
870 pkt_div = mcde_dsi_get_pkt_div(mode->hdisplay, 640);
871 }
872 dev_dbg(drm->dev, "FIFO watermark after flooring: %d bytes\n",
873 fifo_wtrmrk);
874 dev_dbg(drm->dev, "Packet divisor: %d bytes\n", pkt_div);
875
876 /* NOTE: pkt_div is 1 for video mode */
877 pkt_size = (formatter_ppl * formatter_cpp) / pkt_div;
878 /* Commands CMD8 need one extra byte */
879 if (!(mcde->mdsi->mode_flags & MIPI_DSI_MODE_VIDEO))
880 pkt_size++;
881
882 dev_dbg(drm->dev, "DSI packet size: %d * %d bytes per line\n",
883 pkt_size, pkt_div);
884 dev_dbg(drm->dev, "Overlay frame size: %u bytes\n",
885 mode->hdisplay * mode->vdisplay * cpp);
886 mcde->stride = mode->hdisplay * cpp;
887 dev_dbg(drm->dev, "Overlay line stride: %u bytes\n",
888 mcde->stride);
889 /* NOTE: pkt_div is 1 for video mode */
890 formatter_frame = pkt_size * pkt_div * formatter_lpf;
891 dev_dbg(drm->dev, "Formatter frame size: %u bytes\n", formatter_frame);
892
893 /* Drain the FIFO A + channel 0 pipe so we have a clean slate */
894 mcde_drain_pipe(mcde, MCDE_FIFO_A, MCDE_CHANNEL_0);
895
896 /*
897 * We set up our display pipeline:
898 * EXTSRC 0 -> OVERLAY 0 -> CHANNEL 0 -> FIFO A -> DSI FORMATTER 0
899 *
900 * First configure the external source (memory) on external source 0
901 * using the desired bitstream/bitmap format
902 */
903 mcde_configure_extsrc(mcde, MCDE_EXTSRC_0, format);
904
905 /*
906 * Configure overlay 0 according to format and mode and take input
907 * from external source 0 and route the output of this overlay to
908 * channel 0
909 */
910 mcde_configure_overlay(mcde, MCDE_OVERLAY_0, MCDE_EXTSRC_0,
911 MCDE_CHANNEL_0, mode, format);
912
913 /*
914 * Configure pixel-per-line and line-per-frame for channel 0 and then
915 * route channel 0 to FIFO A
916 */
917 mcde_configure_channel(mcde, MCDE_CHANNEL_0, MCDE_FIFO_A, mode);
918
919 /* Configure FIFO A to use DSI formatter 0 */
920 mcde_configure_fifo(mcde, MCDE_FIFO_A, MCDE_DSI_FORMATTER_0,
921 fifo_wtrmrk);
922
923 /* Configure the DSI formatter 0 for the DSI panel output */
924 mcde_configure_dsi_formatter(mcde, MCDE_DSI_FORMATTER_0,
925 formatter_frame, pkt_size);
926
927 if (mcde->te_sync) {
928 if (mode->flags & DRM_MODE_FLAG_NVSYNC)
929 val = MCDE_VSCRC_VSPOL;
930 else
931 val = 0;
932 writel(val, mcde->regs + MCDE_VSCRC0);
933 /* Enable VSYNC capture on TE0 */
934 val = readl(mcde->regs + MCDE_CRC);
935 val |= MCDE_CRC_SYCEN0;
936 writel(val, mcde->regs + MCDE_CRC);
937
938 drm_crtc_vblank_on(crtc);
939 }
940
941 dev_info(drm->dev, "MCDE display is enabled\n");
942}
943
944static void mcde_display_disable(struct drm_simple_display_pipe *pipe)
945{
946 struct drm_crtc *crtc = &pipe->crtc;
947 struct drm_device *drm = crtc->dev;
948 struct mcde *mcde = drm->dev_private;
949
950 if (mcde->te_sync)
951 drm_crtc_vblank_off(crtc);
952
953 /* Disable FIFO A flow */
954 mcde_disable_fifo(mcde, MCDE_FIFO_A, true);
955
956 dev_info(drm->dev, "MCDE display is disabled\n");
957}
958
959static void mcde_display_send_one_frame(struct mcde *mcde)
960{
961 /* Request a TE ACK */
962 if (mcde->te_sync)
963 mcde_dsi_te_request(mcde->mdsi);
964
965 /* Enable FIFO A flow */
966 mcde_enable_fifo(mcde, MCDE_FIFO_A);
967
968 if (mcde->te_sync) {
969 /*
970 * If oneshot mode is enabled, the flow will be disabled
971 * when the TE0 IRQ arrives in the interrupt handler. Otherwise
972 * updates are continuously streamed to the display after this
973 * point.
974 */
975 dev_dbg(mcde->dev, "sent TE0 framebuffer update\n");
976 return;
977 }
978
979 /* Trigger a software sync out on channel 0 */
980 writel(MCDE_CHNLXSYNCHSW_SW_TRIG,
981 mcde->regs + MCDE_CHNL0SYNCHSW);
982
983 /*
984 * Disable FIFO A flow again: since we are using TE sync we
985 * need to wait for the FIFO to drain before we continue
986 * so repeated calls to this function will not cause a mess
987 * in the hardware by pushing updates will updates are going
988 * on already.
989 */
990 mcde_disable_fifo(mcde, MCDE_FIFO_A, true);
991
992 dev_dbg(mcde->dev, "sent SW framebuffer update\n");
993}
994
995static void mcde_set_extsrc(struct mcde *mcde, u32 buffer_address)
996{
997 /* Write bitmap base address to register */
998 writel(buffer_address, mcde->regs + MCDE_EXTSRCXA0);
999 /*
1000 * Base address for next line this is probably only used
1001 * in interlace modes.
1002 */
1003 writel(buffer_address + mcde->stride, mcde->regs + MCDE_EXTSRCXA1);
1004}
1005
1006static void mcde_display_update(struct drm_simple_display_pipe *pipe,
1007 struct drm_plane_state *old_pstate)
1008{
1009 struct drm_crtc *crtc = &pipe->crtc;
1010 struct drm_device *drm = crtc->dev;
1011 struct mcde *mcde = drm->dev_private;
1012 struct drm_pending_vblank_event *event = crtc->state->event;
1013 struct drm_plane *plane = &pipe->plane;
1014 struct drm_plane_state *pstate = plane->state;
1015 struct drm_framebuffer *fb = pstate->fb;
1016
1017 /*
1018 * Handle any pending event first, we need to arm the vblank
1019 * interrupt before sending any update to the display so we don't
1020 * miss the interrupt.
1021 */
1022 if (event) {
1023 crtc->state->event = NULL;
1024
1025 spin_lock_irq(&crtc->dev->event_lock);
1026 /*
1027 * Hardware must be on before we can arm any vblank event,
1028 * this is not a scanout controller where there is always
1029 * some periodic update going on, it is completely frozen
1030 * until we get an update. If MCDE output isn't yet enabled,
1031 * we just send a vblank dummy event back.
1032 */
1033 if (crtc->state->active && drm_crtc_vblank_get(crtc) == 0) {
1034 dev_dbg(mcde->dev, "arm vblank event\n");
1035 drm_crtc_arm_vblank_event(crtc, event);
1036 } else {
1037 dev_dbg(mcde->dev, "insert fake vblank event\n");
1038 drm_crtc_send_vblank_event(crtc, event);
1039 }
1040
1041 spin_unlock_irq(&crtc->dev->event_lock);
1042 }
1043
1044 /*
1045 * We do not start sending framebuffer updates before the
1046 * display is enabled. Update events will however be dispatched
1047 * from the DRM core before the display is enabled.
1048 */
1049 if (fb) {
1050 mcde_set_extsrc(mcde, drm_fb_cma_get_gem_addr(fb, pstate, 0));
1051 /* Send a single frame using software sync */
1052 mcde_display_send_one_frame(mcde);
1053 dev_info_once(mcde->dev, "sent first display update\n");
1054 } else {
1055 /*
1056 * If an update is receieved before the MCDE is enabled
1057 * (before mcde_display_enable() is called) we can't really
1058 * do much with that buffer.
1059 */
1060 dev_info(mcde->dev, "ignored a display update\n");
1061 }
1062}
1063
1064static int mcde_display_enable_vblank(struct drm_simple_display_pipe *pipe)
1065{
1066 struct drm_crtc *crtc = &pipe->crtc;
1067 struct drm_device *drm = crtc->dev;
1068 struct mcde *mcde = drm->dev_private;
1069 u32 val;
1070
1071 /* Enable all VBLANK IRQs */
1072 val = MCDE_PP_VCMPA |
1073 MCDE_PP_VCMPB |
1074 MCDE_PP_VSCC0 |
1075 MCDE_PP_VSCC1 |
1076 MCDE_PP_VCMPC0 |
1077 MCDE_PP_VCMPC1;
1078 writel(val, mcde->regs + MCDE_IMSCPP);
1079
1080 return 0;
1081}
1082
1083static void mcde_display_disable_vblank(struct drm_simple_display_pipe *pipe)
1084{
1085 struct drm_crtc *crtc = &pipe->crtc;
1086 struct drm_device *drm = crtc->dev;
1087 struct mcde *mcde = drm->dev_private;
1088
1089 /* Disable all VBLANK IRQs */
1090 writel(0, mcde->regs + MCDE_IMSCPP);
1091 /* Clear any pending IRQs */
1092 writel(0xFFFFFFFF, mcde->regs + MCDE_RISPP);
1093}
1094
1095static struct drm_simple_display_pipe_funcs mcde_display_funcs = {
1096 .check = mcde_display_check,
1097 .enable = mcde_display_enable,
1098 .disable = mcde_display_disable,
1099 .update = mcde_display_update,
1100 .prepare_fb = drm_gem_fb_simple_display_pipe_prepare_fb,
1101};
1102
1103int mcde_display_init(struct drm_device *drm)
1104{
1105 struct mcde *mcde = drm->dev_private;
1106 int ret;
1107 static const u32 formats[] = {
1108 DRM_FORMAT_ARGB8888,
1109 DRM_FORMAT_ABGR8888,
1110 DRM_FORMAT_XRGB8888,
1111 DRM_FORMAT_XBGR8888,
1112 DRM_FORMAT_RGB888,
1113 DRM_FORMAT_BGR888,
1114 DRM_FORMAT_ARGB4444,
1115 DRM_FORMAT_ABGR4444,
1116 DRM_FORMAT_XRGB4444,
1117 DRM_FORMAT_XBGR4444,
1118 /* These are actually IRGB1555 so intensity bit is lost */
1119 DRM_FORMAT_XRGB1555,
1120 DRM_FORMAT_XBGR1555,
1121 DRM_FORMAT_RGB565,
1122 DRM_FORMAT_BGR565,
1123 DRM_FORMAT_YUV422,
1124 };
1125
1126 /* Provide vblank only when we have TE enabled */
1127 if (mcde->te_sync) {
1128 mcde_display_funcs.enable_vblank = mcde_display_enable_vblank;
1129 mcde_display_funcs.disable_vblank = mcde_display_disable_vblank;
1130 }
1131
1132 ret = drm_simple_display_pipe_init(drm, &mcde->pipe,
1133 &mcde_display_funcs,
1134 formats, ARRAY_SIZE(formats),
1135 NULL,
1136 mcde->connector);
1137 if (ret)
1138 return ret;
1139
1140 return 0;
1141}
1142EXPORT_SYMBOL_GPL(mcde_display_init);