2 * Copyright 2007, 2010-2011 Freescale Semiconductor, Inc.
3 * Authors: York Sun <yorksun@freescale.com>
4 * Timur Tabi <timur@freescale.com>
6 * FSL DIU Framebuffer driver
8 * See file CREDITS for list of people who contributed to this
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
31 #include "videomodes.h"
33 #include <fsl_diu_fb.h>
35 struct fb_var_screeninfo {
36 unsigned int xres; /* visible resolution */
39 unsigned int bits_per_pixel; /* guess what */
41 /* Timing: All values in pixclocks, except pixclock (of course) */
42 unsigned int pixclock; /* pixel clock in ps (pico seconds) */
43 unsigned int left_margin; /* time from sync to picture */
44 unsigned int right_margin; /* time from picture to sync */
45 unsigned int upper_margin; /* time from sync to picture */
46 unsigned int lower_margin;
47 unsigned int hsync_len; /* length of horizontal sync */
48 unsigned int vsync_len; /* length of vertical sync */
49 unsigned int sync; /* see FB_SYNC_* */
50 unsigned int vmode; /* see FB_VMODE_* */
51 unsigned int rotate; /* angle we rotate counter clockwise */
55 struct fb_var_screeninfo var; /* Current var */
56 unsigned int smem_len; /* Length of frame buffer mem */
57 unsigned int type; /* see FB_TYPE_* */
58 unsigned int line_length; /* length of a line in bytes */
61 unsigned long screen_size;
65 const char *name; /* optional */
66 unsigned int refresh; /* optional */
69 unsigned int pixclock;
70 unsigned int left_margin;
71 unsigned int right_margin;
72 unsigned int upper_margin;
73 unsigned int lower_margin;
74 unsigned int hsync_len;
75 unsigned int vsync_len;
81 /* This setting is used for the ifm pdm360ng with PRIMEVIEW PM070WL3 */
82 static struct fb_videomode fsl_diu_mode_800_480 = {
95 .vmode = FB_VMODE_NONINTERLACED
98 /* For the SHARP LQ084S3LG01, used on the P1022DS board */
99 static struct fb_videomode fsl_diu_mode_800_600 = {
100 .name = "800x600-60",
111 .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
112 .vmode = FB_VMODE_NONINTERLACED
116 * These parameters give default parameters
117 * for video output 1024x768,
118 * FIXME - change timing to proper amounts
119 * hsync 31.5kHz, vsync 60Hz
121 static struct fb_videomode fsl_diu_mode_1024_768 = {
122 .name = "1024x768-60",
133 .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
134 .vmode = FB_VMODE_NONINTERLACED
137 static struct fb_videomode fsl_diu_mode_1280_1024 = {
138 .name = "1280x1024-60",
149 .sync = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
150 .vmode = FB_VMODE_NONINTERLACED
154 * These are the fields of area descriptor(in DDR memory) for every plane
157 /* Word 0(32-bit) in DDR memory */
158 __le32 pix_fmt; /* hard coding pixel format */
159 /* Word 1(32-bit) in DDR memory */
161 /* Word 2(32-bit) in DDR memory */
162 __le32 src_size_g_alpha;
163 /* Word 3(32-bit) in DDR memory */
165 /* Word 4(32-bit) in DDR memory */
167 /* Word 5(32-bit) in DDR memory */
169 /* Word 6(32-bit) in DDR memory */
174 /* Word 7(32-bit) in DDR memory */
179 /* Word 8(32-bit) in DDR memory */
181 /* Word 9(32-bit) in DDR memory, just for 64-bit aligned */
183 } __attribute__ ((packed));
209 } __attribute__ ((packed));
212 void *vaddr; /* Virtual address */
213 u32 paddr; /* 32-bit physical address */
214 unsigned int offset; /* Alignment offset */
217 static struct fb_info info;
220 * Align to 64-bit(8-byte), 32-byte, etc.
222 static int allocate_buf(struct diu_addr *buf, u32 size, u32 bytes_align)
227 ssize = size + bytes_align;
228 buf->vaddr = malloc(ssize);
232 memset(buf->vaddr, 0, ssize);
233 mask = bytes_align - 1;
234 offset = (u32)buf->vaddr & mask;
236 buf->offset = bytes_align - offset;
237 buf->vaddr += offset;
241 buf->paddr = virt_to_phys(buf->vaddr);
246 * Allocate a framebuffer and an Area Descriptor that points to it. Both
247 * are created in the same memory block. The Area Descriptor is updated to
248 * point to the framebuffer memory. Memory is aligned as needed.
250 static struct diu_ad *allocate_fb(unsigned int xres, unsigned int yres,
251 unsigned int depth, void **fb)
253 unsigned long size = xres * yres * depth;
254 struct diu_addr addr;
256 size_t ad_size = roundup(sizeof(struct diu_ad), 32);
259 * Allocate a memory block that holds the Area Descriptor and the
260 * frame buffer right behind it. To keep the code simple, everything
261 * is aligned on a 32-byte address.
263 if (allocate_buf(&addr, ad_size + size, 32) < 0)
267 ad->addr = cpu_to_le32(addr.paddr + ad_size);
268 ad->aoi_size = cpu_to_le32((yres << 16) | xres);
269 ad->src_size_g_alpha = cpu_to_le32((yres << 12) | xres);
274 *fb = addr.vaddr + ad_size;
279 int fsl_diu_init(u16 xres, u16 yres, u32 pixel_format, int gamma_fix)
281 struct fb_videomode *fsl_diu_mode_db;
283 struct diu *hw = (struct diu *)CONFIG_SYS_DIU_ADDR;
284 u8 *gamma_table_base;
286 struct diu_ad *dummy_ad;
287 struct diu_addr gamma;
288 struct diu_addr cursor;
290 /* Convert the X,Y resolution pair into a single number */
291 #define RESOLUTION(x, y) (((u32)(x) << 16) | (y))
293 switch (RESOLUTION(xres, yres)) {
294 case RESOLUTION(800, 480):
295 fsl_diu_mode_db = &fsl_diu_mode_800_480;
297 case RESOLUTION(800, 600):
298 fsl_diu_mode_db = &fsl_diu_mode_800_600;
299 case RESOLUTION(1024, 768):
300 fsl_diu_mode_db = &fsl_diu_mode_1024_768;
301 case RESOLUTION(1280, 1024):
302 fsl_diu_mode_db = &fsl_diu_mode_1280_1024;
305 printf("DIU: Unsupported resolution %ux%u\n", xres, yres);
309 /* The AD struct for the dummy framebuffer and the FB itself */
310 dummy_ad = allocate_fb(2, 4, 4, NULL);
312 printf("DIU: Out of memory\n");
315 dummy_ad->pix_fmt = 0x88883316;
318 info.var.xres = fsl_diu_mode_db->xres;
319 info.var.yres = fsl_diu_mode_db->yres;
320 info.var.bits_per_pixel = 32;
321 info.var.pixclock = fsl_diu_mode_db->pixclock;
322 info.var.left_margin = fsl_diu_mode_db->left_margin;
323 info.var.right_margin = fsl_diu_mode_db->right_margin;
324 info.var.upper_margin = fsl_diu_mode_db->upper_margin;
325 info.var.lower_margin = fsl_diu_mode_db->lower_margin;
326 info.var.hsync_len = fsl_diu_mode_db->hsync_len;
327 info.var.vsync_len = fsl_diu_mode_db->vsync_len;
328 info.var.sync = fsl_diu_mode_db->sync;
329 info.var.vmode = fsl_diu_mode_db->vmode;
330 info.line_length = info.var.xres * info.var.bits_per_pixel / 8;
332 /* Memory allocation for framebuffer */
334 info.var.xres * info.var.yres * (info.var.bits_per_pixel / 8);
335 ad = allocate_fb(info.var.xres, info.var.yres,
336 info.var.bits_per_pixel / 8, &info.screen_base);
338 printf("DIU: Out of memory\n");
342 ad->pix_fmt = pixel_format;
344 /* Disable chroma keying function */
353 /* Initialize the gamma table */
354 if (allocate_buf(&gamma, 256 * 3, 32) < 0) {
355 printf("DIU: Out of memory\n");
358 gamma_table_base = gamma.vaddr;
359 for (i = 0; i <= 2; i++)
360 for (j = 0; j < 256; j++)
361 *gamma_table_base++ = j;
363 if (gamma_fix == 1) { /* fix the gamma */
364 gamma_table_base = gamma.vaddr;
365 for (i = 0; i < 256 * 3; i++) {
366 gamma_table_base[i] = (gamma_table_base[i] << 2)
367 | ((gamma_table_base[i] >> 6) & 0x03);
371 /* Initialize the cursor */
372 if (allocate_buf(&cursor, 32 * 32 * 2, 32) < 0) {
373 printf("DIU: Can't alloc cursor data\n");
377 /* Program DIU registers */
378 out_be32(&hw->diu_mode, 0); /* Temporarily disable the DIU */
380 out_be32(&hw->gamma, gamma.paddr);
381 out_be32(&hw->cursor, cursor.paddr);
382 out_be32(&hw->bgnd, 0x007F7F7F);
383 out_be32(&hw->bgnd_wb, 0);
384 out_be32(&hw->disp_size, info.var.yres << 16 | info.var.xres);
385 out_be32(&hw->wb_size, 0);
386 out_be32(&hw->wb_mem_addr, 0);
387 out_be32(&hw->hsyn_para, info.var.left_margin << 22 |
388 info.var.hsync_len << 11 |
389 info.var.right_margin);
391 out_be32(&hw->vsyn_para, info.var.upper_margin << 22 |
392 info.var.vsync_len << 11 |
393 info.var.lower_margin);
395 out_be32(&hw->syn_pol, 0);
396 out_be32(&hw->thresholds, 0x00037800);
397 out_be32(&hw->int_status, 0);
398 out_be32(&hw->int_mask, 0);
399 out_be32(&hw->plut, 0x01F5F666);
400 /* Pixel Clock configuration */
401 diu_set_pixel_clock(info.var.pixclock);
403 /* Set the frame buffers */
404 out_be32(&hw->desc[0], virt_to_phys(ad));
405 out_be32(&hw->desc[1], virt_to_phys(dummy_ad));
406 out_be32(&hw->desc[2], virt_to_phys(dummy_ad));
408 /* Enable the DIU, set display to all three planes */
409 out_be32(&hw->diu_mode, 1);
414 void *video_hw_init(void)
416 static GraphicDevice ctfb;
418 unsigned int depth = 0, freq = 0;
420 if (!video_get_video_mode(&ctfb.winSizeX, &ctfb.winSizeY, &depth, &freq,
424 /* Find the monitor port, which is a required option */
427 if (strncmp(options, "monitor=", 8) != 0)
430 if (platform_diu_init(ctfb.winSizeX, ctfb.winSizeY, options + 8) < 0)
433 /* fill in Graphic device struct */
434 sprintf(ctfb.modeIdent, "%ix%ix%i %ikHz %iHz",
435 ctfb.winSizeX, ctfb.winSizeY, depth, 64, freq);
437 ctfb.frameAdrs = (unsigned int)info.screen_base;
438 ctfb.plnSizeX = ctfb.winSizeX;
439 ctfb.plnSizeY = ctfb.winSizeY;
442 ctfb.gdfIndex = GDF_32BIT_X888RGB;
446 ctfb.memSize = info.screen_size;
448 /* Cursor Start Address */