board/freescale/common/fsl_diu_fb.c

   1 /*
   2  * Copyright 2007 Freescale Semiconductor, Inc.
   3  * York Sun <yorksun@freescale.com>
   4  *
   5  * FSL DIU Framebuffer driver
   6  *
   7  * See file CREDITS for list of people who contributed to this
   8  * project.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License as
  12  * published by the Free Software Foundation; either version 2 of
  13  * the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23  * MA 02111-1307 USA
  24  */
  25
  26
  27 #include <common.h>
  28 #include <i2c.h>
  29 #include <malloc.h>
  30
  31 #ifdef CONFIG_FSL_DIU_FB
  32
  33 #include "fsl_diu_fb.h"
  34
  35
  36 #ifdef DEBUG
  37 #define DPRINTF(fmt, args...) printf("%s: " fmt,__FUNCTION__,## args)
  38 #else
  39 #define DPRINTF(fmt, args...)
  40 #endif
  41
  42
  43 struct fb_videomode {
  44         const char *name;       /* optional */
  45         unsigned int refresh;           /* optional */
  46         unsigned int xres;
  47         unsigned int yres;
  48         unsigned int pixclock;
  49         unsigned int left_margin;
  50         unsigned int right_margin;
  51         unsigned int upper_margin;
  52         unsigned int lower_margin;
  53         unsigned int hsync_len;
  54         unsigned int vsync_len;
  55         unsigned int sync;
  56         unsigned int vmode;
  57         unsigned int flag;
  58 };
  59
  60 #define FB_SYNC_VERT_HIGH_ACT   2       /* vertical sync high active    */
  61 #define FB_SYNC_COMP_HIGH_ACT   8       /* composite sync high active   */
  62 #define FB_VMODE_NONINTERLACED  0       /* non interlaced */
  63
  64 /*
  65  * These parameters give default parameters
  66  * for video output 1024x768,
  67  * FIXME - change timing to proper amounts
  68  * hsync 31.5kHz, vsync 60Hz
  69  */
  70 static struct fb_videomode fsl_diu_mode_1024 = {
  71         .refresh        = 60,
  72         .xres           = 1024,
  73         .yres           = 768,
  74         .pixclock       = 15385,
  75         .left_margin    = 160,
  76         .right_margin   = 24,
  77         .upper_margin   = 29,
  78         .lower_margin   = 3,
  79         .hsync_len      = 136,
  80         .vsync_len      = 6,
  81         .sync           = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  82         .vmode          = FB_VMODE_NONINTERLACED
  83 };
  84
  85 static struct fb_videomode fsl_diu_mode_1280 = {
  86         .name           = "1280x1024-60",
  87         .refresh        = 60,
  88         .xres           = 1280,
  89         .yres           = 1024,
  90         .pixclock       = 9375,
  91         .left_margin    = 38,
  92         .right_margin   = 128,
  93         .upper_margin   = 2,
  94         .lower_margin   = 7,
  95         .hsync_len      = 216,
  96         .vsync_len      = 37,
  97         .sync           = FB_SYNC_COMP_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT,
  98         .vmode          = FB_VMODE_NONINTERLACED
  99 };
 100
 101 /*
 102  * These are the fields of area descriptor(in DDR memory) for every plane
 103  */
 104 struct diu_ad {
 105         /* Word 0(32-bit) in DDR memory */
 106         unsigned int pix_fmt; /* hard coding pixel format */
 107         /* Word 1(32-bit) in DDR memory */
 108         unsigned int addr;
 109         /* Word 2(32-bit) in DDR memory */
 110         unsigned int src_size_g_alpha;
 111         /* Word 3(32-bit) in DDR memory */
 112         unsigned int aoi_size;
 113         /* Word 4(32-bit) in DDR memory */
 114         unsigned int offset_xyi;
 115         /* Word 5(32-bit) in DDR memory */
 116         unsigned int offset_xyd;
 117         /* Word 6(32-bit) in DDR memory */
 118         unsigned int ckmax_r:8;
 119         unsigned int ckmax_g:8;
 120         unsigned int ckmax_b:8;
 121         unsigned int res9:8;
 122         /* Word 7(32-bit) in DDR memory */
 123         unsigned int ckmin_r:8;
 124         unsigned int ckmin_g:8;
 125         unsigned int ckmin_b:8;
 126         unsigned int res10:8;
 127         /* Word 8(32-bit) in DDR memory */
 128         unsigned int next_ad;
 129         /* Word 9(32-bit) in DDR memory, just for 64-bit aligned */
 130         unsigned int res1;
 131         unsigned int res2;
 132         unsigned int res3;
 133 }__attribute__ ((packed));
 134
 135 /*
 136  * DIU register map
 137  */
 138 struct diu {
 139         unsigned int desc[3];
 140         unsigned int gamma;
 141         unsigned int pallete;
 142         unsigned int cursor;
 143         unsigned int curs_pos;
 144         unsigned int diu_mode;
 145         unsigned int bgnd;
 146         unsigned int bgnd_wb;
 147         unsigned int disp_size;
 148         unsigned int wb_size;
 149         unsigned int wb_mem_addr;
 150         unsigned int hsyn_para;
 151         unsigned int vsyn_para;
 152         unsigned int syn_pol;
 153         unsigned int thresholds;
 154         unsigned int int_status;
 155         unsigned int int_mask;
 156         unsigned int colorbar[8];
 157         unsigned int filling;
 158         unsigned int plut;
 159 } __attribute__ ((packed));
 160
 161 struct diu_hw {
 162         struct diu *diu_reg;
 163         volatile unsigned int mode;             /* DIU operation mode */
 164 };
 165
 166 struct diu_addr {
 167         unsigned char  *  paddr;        /* Virtual address */
 168         unsigned int       offset;
 169 };
 170
 171 #define FSL_DIU_BASE_OFFSET     0x2C000 /* Offset of Display Interface Unit */
 172
 173 /*
 174  * Modes of operation of DIU
 175  */
 176 #define MFB_MODE0       0       /* DIU off */
 177 #define MFB_MODE1       1       /* All three planes output to display */
 178 #define MFB_MODE2       2       /* Plane 1 to display,
 179                                  * planes 2+3 written back to memory */
 180 #define MFB_MODE3       3       /* All three planes written back to memory */
 181 #define MFB_MODE4       4       /* Color bar generation */
 182
 183 #define MAX_CURS                32
 184
 185
 186
 187 static struct fb_info fsl_fb_info;
 188 static struct diu_addr gamma, cursor;
 189 static struct diu_ad fsl_diu_fb_ad __attribute__ ((aligned(32)));
 190 static struct diu_ad dummy_ad __attribute__ ((aligned(32)));
 191 static unsigned char *dummy_fb;
 192 static struct diu_hw dr = {
 193         .mode = MFB_MODE1,
 194 };
 195
 196 int fb_enabled = 0;
 197 int fb_initialized = 0;
 198 const int default_xres = 1280;
 199 const int default_pixel_format = 0x88882317;
 200
 201 static int map_video_memory(struct fb_info *info, unsigned long bytes_align);
 202 static void enable_lcdc(void);
 203 static void disable_lcdc(void);
 204 static int fsl_diu_enable_panel(struct fb_info *info);
 205 static int fsl_diu_disable_panel(struct fb_info *info);
 206 static int allocate_buf(struct diu_addr *buf, u32 size, u32 bytes_align);
 207 static u32 get_busfreq(void);
 208
 209
 210 int fsl_diu_init(int xres,
 211                  unsigned int pixel_format,
 212                  int gamma_fix,
 213                  unsigned char *splash_bmp)
 214 {
 215         struct fb_videomode *fsl_diu_mode_db;
 216         struct diu_ad *ad = &fsl_diu_fb_ad;
 217         struct diu *hw;
 218         struct fb_info *info = &fsl_fb_info;
 219         struct fb_var_screeninfo *var = &info->var;
 220         volatile immap_t *immap = (immap_t *)CFG_IMMR;
 221         volatile ccsr_gur_t *gur = &immap->im_gur;
 222         volatile unsigned int *guts_clkdvdr = &gur->clkdvdr;
 223         unsigned char *gamma_table_base;
 224         unsigned int i, j;
 225         unsigned long speed_ccb, temp, pixval;
 226
 227         DPRINTF("Enter fsl_diu_init\n");
 228         dr.diu_reg = (struct diu *) (CFG_IMMR + FSL_DIU_BASE_OFFSET);
 229         hw = (struct diu *) dr.diu_reg;
 230
 231         disable_lcdc();
 232
 233         if (xres == 1280) {
 234                 fsl_diu_mode_db = &fsl_diu_mode_1280;
 235         } else {
 236                 fsl_diu_mode_db = &fsl_diu_mode_1024;
 237         }
 238
 239         if (0 == fb_initialized) {
 240                 allocate_buf(&gamma, 768, 32);
 241                 DPRINTF("gamma is allocated @ 0x%x\n",
 242                         (unsigned int)gamma.paddr);
 243                 allocate_buf(&cursor, MAX_CURS * MAX_CURS * 2, 32);
 244                 DPRINTF("curosr is allocated @ 0x%x\n",
 245                         (unsigned int)cursor.paddr);
 246
 247                 /* create a dummy fb and dummy ad */
 248                 dummy_fb = malloc(64);
 249                 if (NULL == dummy_fb) {
 250                         printf("Cannot allocate dummy fb\n");
 251                         return -1;
 252                 }
 253                 dummy_ad.addr = cpu_to_le32((unsigned int)dummy_fb);
 254                 dummy_ad.pix_fmt = 0x88882317;
 255                 dummy_ad.src_size_g_alpha = 0x04400000; /* alpha = 0 */
 256                 dummy_ad.aoi_size = 0x02000400;
 257                 dummy_ad.offset_xyi = 0;
 258                 dummy_ad.offset_xyd = 0;
 259                 dummy_ad.next_ad = 0;
 260                 /* Memory allocation for framebuffer */
 261                 if (map_video_memory(info, 32)) {
 262                         printf("Unable to allocate fb memory 1\n");
 263                         return -1;
 264                 }
 265         } else {
 266                 memset(info->screen_base, 0, info->smem_len);
 267         }
 268
 269         dr.diu_reg->desc[0] = (unsigned int) &dummy_ad;
 270         dr.diu_reg->desc[1] = (unsigned int) &dummy_ad;
 271         dr.diu_reg->desc[2] = (unsigned int) &dummy_ad;
 272         DPRINTF("dummy dr.diu_reg->desc[0] = 0x%x\n", dr.diu_reg->desc[0]);
 273         DPRINTF("dummy desc[0] = 0x%x\n", hw->desc[0]);
 274
 275         /* read mode info */
 276         var->xres = fsl_diu_mode_db->xres;
 277         var->yres = fsl_diu_mode_db->yres;
 278         var->bits_per_pixel = 32;
 279         var->pixclock = fsl_diu_mode_db->pixclock;
 280         var->left_margin = fsl_diu_mode_db->left_margin;
 281         var->right_margin = fsl_diu_mode_db->right_margin;
 282         var->upper_margin = fsl_diu_mode_db->upper_margin;
 283         var->lower_margin = fsl_diu_mode_db->lower_margin;
 284         var->hsync_len = fsl_diu_mode_db->hsync_len;
 285         var->vsync_len = fsl_diu_mode_db->vsync_len;
 286         var->sync = fsl_diu_mode_db->sync;
 287         var->vmode = fsl_diu_mode_db->vmode;
 288         info->line_length = var->xres * var->bits_per_pixel / 8;
 289         info->logo_size = 0;
 290         info->logo_height = 0;
 291
 292         ad->pix_fmt = pixel_format;
 293         ad->addr    = cpu_to_le32((unsigned int)info->screen_base);
 294         ad->src_size_g_alpha
 295                         = cpu_to_le32((var->yres << 12) | var->xres);
 296         /* fix me. AOI should not be greater than display size */
 297         ad->aoi_size    = cpu_to_le32(( var->yres << 16) |  var->xres);
 298         ad->offset_xyi = 0;
 299         ad->offset_xyd = 0;
 300
 301         /* Disable chroma keying function */
 302         ad->ckmax_r = 0;
 303         ad->ckmax_g = 0;
 304         ad->ckmax_b = 0;
 305
 306         ad->ckmin_r = 255;
 307         ad->ckmin_g = 255;
 308         ad->ckmin_b = 255;
 309
 310         gamma_table_base = gamma.paddr;
 311         DPRINTF("gamma_table_base is allocated @ 0x%x\n",
 312                 (unsigned int)gamma_table_base);
 313
 314         /* Prep for DIU init  - gamma table */
 315
 316         for (i = 0; i <= 2; i++)
 317                 for (j = 0; j <= 255; j++)
 318                         *gamma_table_base++ = j;
 319
 320         if (gamma_fix == 1) {   /* fix the gamma */
 321                 DPRINTF("Fix gamma table\n");
 322                 gamma_table_base = gamma.paddr;
 323                 for (i = 0; i < 256*3; i++) {
 324                         gamma_table_base[i] = (gamma_table_base[i] << 2)
 325                                 | ((gamma_table_base[i] >> 6) & 0x03);
 326                 }
 327         }
 328
 329         DPRINTF("update-lcdc: HW - %p\n Disabling DIU\n", hw);
 330
 331         /* Program DIU registers */
 332
 333         hw->gamma = (unsigned int) gamma.paddr;
 334         hw->cursor= (unsigned int) cursor.paddr;
 335         hw->bgnd = 0x007F7F7F;                          /* BGND */
 336         hw->bgnd_wb = 0;                                /* BGND_WB */
 337         hw->disp_size = var->yres << 16 | var->xres;    /* DISP SIZE */
 338         hw->wb_size = 0;                                /* WB SIZE */
 339         hw->wb_mem_addr = 0;                            /* WB MEM ADDR */
 340         hw->hsyn_para = var->left_margin << 22 |        /* BP_H */
 341                         var->hsync_len << 11   |        /* PW_H */
 342                         var->right_margin;              /* FP_H */
 343         hw->vsyn_para = var->upper_margin << 22 |       /* BP_V */
 344                         var->vsync_len << 11    |       /* PW_V  */
 345                         var->lower_margin;              /* FP_V  */
 346
 347         /* Pixel Clock configuration */
 348         DPRINTF("DIU: Bus Frequency = %d\n", get_busfreq());
 349         speed_ccb = get_busfreq();
 350
 351         DPRINTF("DIU pixclock in ps - %d\n", var->pixclock);
 352         temp = 1;
 353         temp *= 1000000000;
 354         temp /= var->pixclock;
 355         temp *= 1000;
 356         pixval = speed_ccb / temp;
 357         DPRINTF("DIU pixval = %lu\n", pixval);
 358
 359         hw->syn_pol = 0;                        /* SYNC SIGNALS POLARITY */
 360         hw->thresholds = 0x00037800;            /* The Thresholds */
 361         hw->int_status = 0;                     /* INTERRUPT STATUS */
 362         hw->int_mask = 0;                       /* INT MASK */
 363         hw->plut = 0x01F5F666;
 364
 365         /* Modify PXCLK in GUTS CLKDVDR */
 366         DPRINTF("DIU: Current value of CLKDVDR = 0x%08x\n", *guts_clkdvdr);
 367         temp = *guts_clkdvdr & 0x2000FFFF;
 368         *guts_clkdvdr = temp;                           /* turn off clock */
 369         *guts_clkdvdr = temp | 0x80000000 | ((pixval & 0x1F) << 16);
 370         DPRINTF("DIU: Modified value of CLKDVDR = 0x%08x\n", *guts_clkdvdr);
 371
 372         fb_initialized = 1;
 373
 374         if (splash_bmp) {
 375                 info->logo_height = fsl_diu_display_bmp(splash_bmp, 0, 0, 0);
 376                 info->logo_size = info->logo_height * info->line_length;
 377                 DPRINTF("logo height %d, logo_size 0x%x\n",
 378                         info->logo_height,info->logo_size);
 379         }
 380
 381         /* Enable the DIU */
 382         fsl_diu_enable_panel(info);
 383         enable_lcdc();
 384
 385         return 0;
 386 }
 387
 388 char *fsl_fb_open(struct fb_info **info)
 389 {
 390         *info = &fsl_fb_info;
 391         return (char *) ((unsigned int)(*info)->screen_base
 392                          + (*info)->logo_size);
 393 }
 394
 395 void fsl_diu_close(void)
 396 {
 397         struct fb_info *info = &fsl_fb_info;
 398         fsl_diu_disable_panel(info);
 399 }
 400
 401 static int fsl_diu_enable_panel(struct fb_info *info)
 402 {
 403         struct diu *hw = dr.diu_reg;
 404         struct diu_ad *ad = &fsl_diu_fb_ad;
 405
 406         DPRINTF("Entered: enable_panel\n");
 407         if (hw->desc[0] != (unsigned int)ad)
 408                 hw->desc[0] = (unsigned int)ad;
 409         DPRINTF("desc[0] = 0x%x\n", hw->desc[0]);
 410         return 0;
 411 }
 412
 413 static int fsl_diu_disable_panel(struct fb_info *info)
 414 {
 415         struct diu *hw = dr.diu_reg;
 416
 417         DPRINTF("Entered: disable_panel\n");
 418         if (hw->desc[0] != (unsigned int)&dummy_ad)
 419                 hw->desc[0] = (unsigned int)&dummy_ad;
 420         return 0;
 421 }
 422
 423 static int map_video_memory(struct fb_info *info, unsigned long bytes_align)
 424 {
 425         unsigned long offset;
 426         unsigned long mask;
 427
 428         DPRINTF("Entered: map_video_memory\n");
 429         /* allocate maximum 1280*1024 with 32bpp */
 430         info->smem_len = 1280 * 4 *1024 + bytes_align;
 431         DPRINTF("MAP_VIDEO_MEMORY: smem_len = %d\n", info->smem_len);
 432         info->screen_base = malloc(info->smem_len);
 433         if (info->screen_base == NULL) {
 434                 printf("Unable to allocate fb memory\n");
 435                 return -1;
 436         }
 437         info->smem_start = (unsigned int) info->screen_base;
 438         mask = bytes_align - 1;
 439         offset = (unsigned long)info->screen_base & mask;
 440         if (offset) {
 441                 info->screen_base += offset;
 442                 info->smem_len = info->smem_len - (bytes_align - offset);
 443         } else
 444                 info->smem_len = info->smem_len - bytes_align;
 445
 446         info->screen_size = info->smem_len;
 447
 448         DPRINTF("Allocated fb @ 0x%08lx, size=%d.\n",
 449                 info->smem_start, info->smem_len);
 450
 451         return 0;
 452 }
 453
 454 static void enable_lcdc(void)
 455 {
 456         struct diu *hw = dr.diu_reg;
 457
 458         DPRINTF("Entered: enable_lcdc, fb_enabled = %d\n", fb_enabled);
 459         if (!fb_enabled) {
 460                 hw->diu_mode = dr.mode;
 461                 fb_enabled++;
 462         }
 463         DPRINTF("diu_mode = %d\n", hw->diu_mode);
 464 }
 465
 466 static void disable_lcdc(void)
 467 {
 468         struct diu *hw = dr.diu_reg;
 469
 470         DPRINTF("Entered: disable_lcdc, fb_enabled = %d\n", fb_enabled);
 471         if (fb_enabled) {
 472                 hw->diu_mode = 0;
 473                 fb_enabled = 0;
 474         }
 475 }
 476
 477 static u32 get_busfreq(void)
 478 {
 479         u32 fs_busfreq = 0;
 480
 481         fs_busfreq = get_bus_freq(0);
 482         return fs_busfreq;
 483 }
 484
 485 /*
 486  * Align to 64-bit(8-byte), 32-byte, etc.
 487  */
 488 static int allocate_buf(struct diu_addr *buf, u32 size, u32 bytes_align)
 489 {
 490         u32 offset, ssize;
 491         u32 mask;
 492
 493         DPRINTF("Entered: allocate_buf\n");
 494         ssize = size + bytes_align;
 495         buf->paddr = malloc(ssize);
 496         if (!buf->paddr)
 497                 return -1;
 498
 499         memset(buf->paddr, 0, ssize);
 500         mask = bytes_align - 1;
 501         offset = (u32)buf->paddr & mask;
 502         if (offset) {
 503                 buf->offset = bytes_align - offset;
 504                 buf->paddr = (unsigned char *) ((u32)buf->paddr + offset);
 505         } else
 506                 buf->offset = 0;
 507         return 0;
 508 }
 509
 510 int fsl_diu_display_bmp(unsigned char *bmp,
 511                         int xoffset,
 512                         int yoffset,
 513                         int transpar)
 514 {
 515         struct fb_info *info = &fsl_fb_info;
 516         unsigned char r, g, b;
 517         unsigned int *fb_t, val;
 518         unsigned char *bitmap;
 519         unsigned int palette[256];
 520         int width, height, bpp, ncolors, raster, offset, x, y, i, k, cpp;
 521
 522         if (!bmp) {
 523                 printf("Must supply a bitmap address\n");
 524                 return 0;
 525         }
 526
 527         raster = bmp[10] + (bmp[11] << 8) + (bmp[12] << 16) + (bmp[13] << 24);
 528         width  = (bmp[21] << 24) | (bmp[20] << 16) | (bmp[19] << 8) | bmp[18];
 529         height = (bmp[25] << 24) | (bmp[24] << 16) | (bmp[23] << 8) | bmp[22];
 530         bpp  = (bmp[29] <<  8) | (bmp[28]);
 531         ncolors = bmp[46] + (bmp[47] << 8) + (bmp[48] << 16) + (bmp[49] << 24);
 532         bitmap   = bmp + raster;
 533         cpp = info->var.bits_per_pixel / 8;
 534
 535         DPRINTF("bmp = 0x%08x\n", (unsigned int)bmp);
 536         DPRINTF("bitmap = 0x%08x\n", (unsigned int)bitmap);
 537         DPRINTF("width = %d\n", width);
 538         DPRINTF("height = %d\n", height);
 539         DPRINTF("bpp = %d\n", bpp);
 540         DPRINTF("ncolors = %d\n", ncolors);
 541
 542         DPRINTF("xres = %d\n", info->var.xres);
 543         DPRINTF("yres = %d\n", info->var.yres);
 544         DPRINTF("Screen_base = 0x%x\n", (unsigned int)info->screen_base);
 545
 546         if (((width+xoffset) > info->var.xres) ||
 547             ((height+yoffset) > info->var.yres)) {
 548                 printf("bitmap is out of range, image too large or too much offset\n");
 549                 return 0;
 550         }
 551         if (bpp < 24) {
 552                 for (i = 0, offset = 54; i < ncolors; i++, offset += 4)
 553                         palette[i] = (bmp[offset+2] << 16)
 554                                 + (bmp[offset+1] << 8) + bmp[offset];
 555         }
 556
 557         switch (bpp) {
 558         case 1:
 559                 for (y = height - 1; y >= 0; y--) {
 560                         fb_t = (unsigned int *) ((unsigned int)info->screen_base + (((y+yoffset) * info->var.xres) + xoffset)*cpp);
 561                         for (x = 0; x < width; x += 8) {
 562                                 b = *bitmap++;
 563                                 for (k = 0; k < 8; k++) {
 564                                         if (b & 0x80)
 565                                                 *fb_t = palette[1];
 566                                         else
 567                                                 *fb_t = palette[0];
 568                                         b = b << 1;
 569                                 }
 570                         }
 571                         for (i = (width / 2) % 4; i > 0; i--)
 572                                 bitmap++;
 573                 }
 574                 break;
 575         case 4:
 576                 for (y = height - 1; y >= 0; y--) {
 577                         fb_t = (unsigned int *) ((unsigned int)info->screen_base + (((y+yoffset) * info->var.xres) + xoffset)*cpp);
 578                         for (x = 0; x < width; x += 2) {
 579                                 b = *bitmap++;
 580                                 r = (b >> 4) & 0x0F;
 581                                 g =  b & 0x0F;
 582                                 *fb_t++ = palette[r];
 583                                 *fb_t++ = palette[g];
 584                         }
 585                         for (i = (width / 2) % 4; i > 0; i--)
 586                                 bitmap++;
 587                 }
 588                 break;
 589         case 8:
 590                 for (y = height - 1; y >= 0; y--) {
 591                         fb_t = (unsigned int *) ((unsigned int)info->screen_base + (((y+yoffset) * info->var.xres) + xoffset)*cpp);
 592                         for (x = 0; x < width; x++) {
 593                                 *fb_t++ = palette[ *bitmap++ ];
 594                         }
 595                         for (i = (width / 2) % 4; i > 0; i--)
 596                                 bitmap++;
 597                 }
 598                 break;
 599         case 24:
 600                 for (y = height - 1; y >= 0; y--) {
 601                         fb_t = (unsigned int *) ((unsigned int)info->screen_base + (((y+yoffset) * info->var.xres) + xoffset)*cpp);
 602                         for (x = 0; x < width; x++) {
 603                                 b = *bitmap++;
 604                                 g = *bitmap++;
 605                                 r = *bitmap++;
 606                                 val = (r << 16) + (g << 8) + b;
 607                                 *fb_t++ = val;
 608                         }
 609                         for (; (x % 4) != 0; x++)       /* 4-byte alignment */
 610                                 bitmap++;
 611                 }
 612                 break;
 613         }
 614
 615         return height;
 616 }
 617
 618 void fsl_diu_clear_screen(void)
 619 {
 620         struct fb_info *info = &fsl_fb_info;
 621
 622         memset(info->screen_base, 0, info->smem_len);
 623 }
 624 #endif /* CONFIG_FSL_DIU_FB */