5 * Stefano Babic, DENX Software Engineering, sbabic@denx.de
7 * IPUv3 Linux framebuffer:
9 * (C) Copyright 2004-2011 Freescale Semiconductor, Inc.
11 * SPDX-License-Identifier: GPL-2.0+
16 #include <asm/errno.h>
17 #include <linux/string.h>
18 #include <linux/list.h>
28 #include "videomodes.h"
30 DECLARE_GLOBAL_DATA_PTR;
32 static int mxcfb_map_video_memory(struct fb_info *fbi);
33 static int mxcfb_unmap_video_memory(struct fb_info *fbi);
35 void lcd_initcolregs(void)
39 void lcd_setcolreg(ushort regno, ushort red, ushort green, ushort blue)
43 static void fb_videomode_to_var(struct fb_var_screeninfo *var,
44 const struct fb_videomode *mode)
46 var->xres = mode->xres;
47 var->yres = mode->yres;
48 var->xres_virtual = mode->xres;
49 var->yres_virtual = mode->yres;
52 var->pixclock = mode->pixclock;
53 var->left_margin = mode->left_margin;
54 var->right_margin = mode->right_margin;
55 var->upper_margin = mode->upper_margin;
56 var->lower_margin = mode->lower_margin;
57 var->hsync_len = mode->hsync_len;
58 var->vsync_len = mode->vsync_len;
59 var->sync = mode->sync;
60 var->vmode = mode->vmode & FB_VMODE_MASK;
64 * Structure containing the MXC specific framebuffer information.
71 unsigned char overlay;
72 unsigned char alpha_chan_en;
73 dma_addr_t alpha_phy_addr0;
74 dma_addr_t alpha_phy_addr1;
75 void *alpha_virt_addr0;
76 void *alpha_virt_addr1;
77 uint32_t alpha_mem_len;
79 uint32_t cur_ipu_alpha_buf;
81 u32 pseudo_palette[16];
91 static unsigned long default_bpp = 16;
92 static unsigned char g_dp_in_use;
93 static struct fb_info *mxcfb_info[3];
94 static int ext_clk_used;
96 static uint32_t bpp_to_pixfmt(struct fb_info *fbi)
100 debug("bpp_to_pixfmt: %d\n", fbi->var.bits_per_pixel);
103 return fbi->var.nonstd;
105 switch (fbi->var.bits_per_pixel) {
107 pixfmt = IPU_PIX_FMT_BGR24;
110 pixfmt = IPU_PIX_FMT_BGR32;
113 pixfmt = IPU_PIX_FMT_RGB565;
116 pixfmt = IPU_PIX_FMT_GENERIC;
122 * Set fixed framebuffer parameters based on variable settings.
124 * @param info framebuffer information pointer
126 static int mxcfb_set_fix(struct fb_info *info)
128 struct fb_fix_screeninfo *fix = &info->fix;
129 struct fb_var_screeninfo *var = &info->var;
131 fix->line_length = var->xres_virtual * var->bits_per_pixel / 8;
133 fix->type = FB_TYPE_PACKED_PIXELS;
134 fix->accel = FB_ACCEL_NONE;
135 fix->visual = FB_VISUAL_TRUECOLOR;
142 static int setup_disp_channel1(struct fb_info *fbi)
144 ipu_channel_params_t params;
145 struct mxcfb_info *mxc_fbi = fbi->par;
147 memset(¶ms, 0, sizeof(params));
148 params.mem_dp_bg_sync.di = mxc_fbi->ipu_di;
150 debug("%s called\n", __func__);
152 * Assuming interlaced means yuv output, below setting also
153 * valid for mem_dc_sync. FG should have the same vmode as BG.
155 if (fbi->var.vmode & FB_VMODE_INTERLACED) {
156 params.mem_dp_bg_sync.interlaced = 1;
157 params.mem_dp_bg_sync.out_pixel_fmt =
160 if (mxc_fbi->ipu_di_pix_fmt) {
161 params.mem_dp_bg_sync.out_pixel_fmt =
162 mxc_fbi->ipu_di_pix_fmt;
164 params.mem_dp_bg_sync.out_pixel_fmt =
168 params.mem_dp_bg_sync.in_pixel_fmt = bpp_to_pixfmt(fbi);
169 if (mxc_fbi->alpha_chan_en)
170 params.mem_dp_bg_sync.alpha_chan_en = 1;
172 ipu_init_channel(mxc_fbi->ipu_ch, ¶ms);
177 static int setup_disp_channel2(struct fb_info *fbi)
180 struct mxcfb_info *mxc_fbi = fbi->par;
182 mxc_fbi->cur_ipu_buf = 1;
183 if (mxc_fbi->alpha_chan_en)
184 mxc_fbi->cur_ipu_alpha_buf = 1;
186 fbi->var.xoffset = fbi->var.yoffset = 0;
188 debug("%s: ch: %08x xres: %d yres: %d line_length: %d mem: %08lx .. %08lx\n",
193 fbi->fix.line_length,
195 fbi->fix.smem_start +
196 (fbi->fix.line_length * fbi->var.yres) - 1);
198 retval = ipu_init_channel_buffer(mxc_fbi->ipu_ch, IPU_INPUT_BUFFER,
200 fbi->var.xres, fbi->var.yres,
201 fbi->fix.line_length,
202 fbi->fix.smem_start +
203 (fbi->fix.line_length * fbi->var.yres),
207 printf("ipu_init_channel_buffer error %d\n", retval);
213 * Set framebuffer parameters and change the operating mode.
215 * @param info framebuffer information pointer
217 static int mxcfb_set_par(struct fb_info *fbi)
221 ipu_di_signal_cfg_t sig_cfg;
222 struct mxcfb_info *mxc_fbi = fbi->par;
223 uint32_t out_pixel_fmt;
225 ipu_disable_channel(mxc_fbi->ipu_ch);
226 ipu_uninit_channel(mxc_fbi->ipu_ch);
229 mem_len = fbi->var.yres_virtual * fbi->fix.line_length;
230 if (!fbi->fix.smem_start || (mem_len > fbi->fix.smem_len)) {
231 if (fbi->fix.smem_start)
232 mxcfb_unmap_video_memory(fbi);
234 if (mxcfb_map_video_memory(fbi) < 0)
238 setup_disp_channel1(fbi);
240 memset(&sig_cfg, 0, sizeof(sig_cfg));
241 if (fbi->var.vmode & FB_VMODE_INTERLACED) {
242 sig_cfg.interlaced = 1;
243 out_pixel_fmt = IPU_PIX_FMT_YUV444;
245 if (mxc_fbi->ipu_di_pix_fmt)
246 out_pixel_fmt = mxc_fbi->ipu_di_pix_fmt;
248 out_pixel_fmt = IPU_PIX_FMT_RGB666;
250 if (fbi->var.vmode & FB_VMODE_ODD_FLD_FIRST) /* PAL */
251 sig_cfg.odd_field_first = 1;
252 if ((fbi->var.sync & FB_SYNC_EXT) || ext_clk_used)
254 if (fbi->var.sync & FB_SYNC_HOR_HIGH_ACT)
255 sig_cfg.Hsync_pol = 1;
256 if (fbi->var.sync & FB_SYNC_VERT_HIGH_ACT)
257 sig_cfg.Vsync_pol = 1;
258 if (!(fbi->var.sync & FB_SYNC_CLK_LAT_FALL))
260 if (fbi->var.sync & FB_SYNC_DATA_INVERT)
261 sig_cfg.data_pol = 1;
262 if (!(fbi->var.sync & FB_SYNC_OE_LOW_ACT))
263 sig_cfg.enable_pol = 1;
264 if (fbi->var.sync & FB_SYNC_CLK_IDLE_EN)
265 sig_cfg.clkidle_en = 1;
267 debug("pixclock = %lu.%03lu MHz\n",
268 PICOS2KHZ(fbi->var.pixclock) / 1000,
269 PICOS2KHZ(fbi->var.pixclock) % 1000);
271 retval = ipu_init_sync_panel(mxc_fbi->ipu_di,
272 (PICOS2KHZ(fbi->var.pixclock)) * 1000UL,
273 fbi->var.xres, fbi->var.yres,
275 fbi->var.left_margin,
277 fbi->var.right_margin,
278 fbi->var.upper_margin,
280 fbi->var.lower_margin,
283 printf("mxc_ipuv3_fb: Error %d initializing panel\n", retval);
287 retval = setup_disp_channel2(fbi);
291 if (mxc_fbi->blank == FB_BLANK_UNBLANK)
292 ipu_enable_channel(mxc_fbi->ipu_ch);
298 * Check framebuffer variable parameters and adjust to valid values.
300 * @param var framebuffer variable parameters
302 * @param info framebuffer information pointer
304 static int mxcfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
309 if (var->xres_virtual < var->xres)
310 var->xres_virtual = var->xres;
311 if (var->yres_virtual < var->yres)
312 var->yres_virtual = var->yres;
314 if ((var->bits_per_pixel != 32) && (var->bits_per_pixel != 24) &&
315 (var->bits_per_pixel != 16) && (var->bits_per_pixel != 8))
316 var->bits_per_pixel = default_bpp;
318 switch (var->bits_per_pixel) {
322 var->red.msb_right = 0;
324 var->green.length = 3;
325 var->green.offset = 2;
326 var->green.msb_right = 0;
328 var->blue.length = 2;
329 var->blue.offset = 0;
330 var->blue.msb_right = 0;
332 var->transp.length = 0;
333 var->transp.offset = 0;
334 var->transp.msb_right = 0;
338 var->red.offset = 11;
339 var->red.msb_right = 0;
341 var->green.length = 6;
342 var->green.offset = 5;
343 var->green.msb_right = 0;
345 var->blue.length = 5;
346 var->blue.offset = 0;
347 var->blue.msb_right = 0;
349 var->transp.length = 0;
350 var->transp.offset = 0;
351 var->transp.msb_right = 0;
355 var->red.offset = 16;
356 var->red.msb_right = 0;
358 var->green.length = 8;
359 var->green.offset = 8;
360 var->green.msb_right = 0;
362 var->blue.length = 8;
363 var->blue.offset = 0;
364 var->blue.msb_right = 0;
366 var->transp.length = 0;
367 var->transp.offset = 0;
368 var->transp.msb_right = 0;
372 var->red.offset = 16;
373 var->red.msb_right = 0;
375 var->green.length = 8;
376 var->green.offset = 8;
377 var->green.msb_right = 0;
379 var->blue.length = 8;
380 var->blue.offset = 0;
381 var->blue.msb_right = 0;
383 var->transp.length = 8;
384 var->transp.offset = 24;
385 var->transp.msb_right = 0;
389 if (var->pixclock < 1000) {
390 htotal = var->xres + var->right_margin + var->hsync_len +
392 vtotal = var->yres + var->lower_margin + var->vsync_len +
394 var->pixclock = (vtotal * htotal * 6UL) / 100UL;
395 var->pixclock = KHZ2PICOS(var->pixclock);
396 printf("pixclock set for 60Hz refresh = %u ps\n",
407 static int mxcfb_map_video_memory(struct fb_info *fbi)
409 if (fbi->fix.smem_len < fbi->var.yres_virtual * fbi->fix.line_length) {
410 fbi->fix.smem_len = fbi->var.yres_virtual *
411 fbi->fix.line_length;
414 fbi->screen_base = (void *)gd->fb_base;
416 fbi->screen_base = malloc(fbi->fix.smem_len);
417 if (fbi->screen_base == NULL) {
418 puts("Unable to allocate framebuffer memory\n");
419 fbi->fix.smem_len = 0;
422 fbi->fix.smem_start = (unsigned long)fbi->screen_base;
424 debug("allocated fb @ paddr=0x%08X, size=%d.\n",
425 (uint32_t) fbi->fix.smem_start, fbi->fix.smem_len);
427 fbi->screen_size = fbi->fix.smem_len;
432 static int mxcfb_unmap_video_memory(struct fb_info *fbi)
434 fbi->screen_base = 0;
435 fbi->fix.smem_start = 0;
436 fbi->fix.smem_len = 0;
440 void ipuv3_fb_shutdown(void)
443 struct ipu_stat *stat = (struct ipu_stat *)IPU_STAT;
445 for (i = 0; i < ARRAY_SIZE(mxcfb_info); i++) {
446 struct fb_info *fbi = mxcfb_info[i];
449 struct mxcfb_info *mxc_fbi = fbi->par;
451 ipu_disable_channel(mxc_fbi->ipu_ch);
452 ipu_uninit_channel(mxc_fbi->ipu_ch);
456 clk_enable(g_ipu_clk);
457 for (i = 0; i < ARRAY_SIZE(stat->int_stat); i++) {
458 __raw_writel(__raw_readl(&stat->int_stat[i]),
461 clk_disable(g_ipu_clk);
465 * Initializes the framebuffer information pointer. After allocating
466 * sufficient memory for the framebuffer structure, the fields are
467 * filled with custom information passed in from the configurable
468 * structures. This includes information such as bits per pixel,
469 * color maps, screen width/height and RGBA offsets.
471 * @return Framebuffer structure initialized with our information
473 static struct fb_info *mxcfb_init_fbinfo(void)
476 struct mxcfb_info *mxcfbi;
478 int size = ALIGN(sizeof(struct mxcfb_info), sizeof(long)) +
479 sizeof(struct fb_info);
481 debug("%s: %d %d %d\n",
484 sizeof(struct mxcfb_info),
485 sizeof(struct fb_info));
487 * Allocate sufficient memory for the fb structure
497 fbi->par = p + ALIGN(sizeof(struct fb_info), sizeof(long));
500 debug("Framebuffer structures at: fbi=%p mxcfbi=%p\n",
503 fbi->var.activate = FB_ACTIVATE_NOW;
505 fbi->flags = FBINFO_FLAG_DEFAULT;
506 fbi->pseudo_palette = mxcfbi->pseudo_palette;
512 * Probe routine for the framebuffer driver. It is called during the
513 * driver binding process. The following functions are performed in
514 * this routine: Framebuffer initialization, Memory allocation and
515 * mapping, Framebuffer registration, IPU initialization.
517 * @return Appropriate error code to the kernel common code
519 static int mxcfb_probe(u32 interface_pix_fmt, struct fb_videomode *mode, int di)
522 struct mxcfb_info *mxcfbi;
525 * Initialize FB structures
527 fbi = mxcfb_init_fbinfo();
534 mxcfbi->ipu_ch = MEM_BG_SYNC;
535 mxcfbi->blank = FB_BLANK_UNBLANK;
537 mxcfbi->ipu_ch = MEM_DC_SYNC;
538 mxcfbi->blank = FB_BLANK_POWERDOWN;
543 ipu_disp_set_global_alpha(mxcfbi->ipu_ch, 1, 0x80);
544 ipu_disp_set_color_key(mxcfbi->ipu_ch, 0, 0);
545 strcpy(fbi->fix.id, "DISP3 BG");
549 mxcfb_info[mxcfbi->ipu_di] = fbi;
551 /* Need dummy values until real panel is configured */
552 fbi->var.xres = panel_info.vl_col;
553 fbi->var.yres = panel_info.vl_row;
555 mxcfbi->ipu_di_pix_fmt = interface_pix_fmt;
556 fb_videomode_to_var(&fbi->var, mode);
557 fbi->var.bits_per_pixel = NBITS(panel_info.vl_bpix);
558 fbi->fix.line_length = fbi->var.xres * (fbi->var.bits_per_pixel / 8);
559 fbi->fix.smem_len = fbi->var.yres_virtual * fbi->fix.line_length;
561 mxcfb_check_var(&fbi->var, fbi);
563 /* Default Y virtual size is 2x panel size */
564 fbi->var.yres_virtual = fbi->var.yres * 2;
568 /* allocate fb first */
569 if (mxcfb_map_video_memory(fbi) < 0)
574 lcd_line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
576 debug("MXC IPUV3 configured\n"
577 "XRES = %d YRES = %d BitsXpixel = %d\n",
582 ipu_dump_registers();
587 ulong calc_fbsize(void)
589 return (panel_info.vl_col * panel_info.vl_row *
590 NBITS(panel_info.vl_bpix)) / 8;
593 int ipuv3_fb_init(struct fb_videomode *mode, int di, unsigned int interface_pix_fmt,
594 ipu_di_clk_parent_t di_clk_parent, unsigned long di_clk_val, int bpp)
600 ret = ipu_probe(di, di_clk_parent, di_clk_val);
602 printf("Error initializing IPU\n");
606 return mxcfb_probe(interface_pix_fmt, mode, di);