git.sur5r.net Git - u-boot/blob - drivers/video/da8xx-fb.c

   1 /*
   2  * Porting to u-boot:
   3  *
   4  * (C) Copyright 2011
   5  * Stefano Babic, DENX Software Engineering, sbabic@denx.de.
   6  *
   7  * Copyright (C) 2008-2009 MontaVista Software Inc.
   8  * Copyright (C) 2008-2009 Texas Instruments Inc
   9  *
  10  * Based on the LCD driver for TI Avalanche processors written by
  11  * Ajay Singh and Shalom Hai.
  12  *
  13  * SPDX-License-Identifier:     GPL-2.0+
  14  */
  15
  16 #include <common.h>
  17 #include <malloc.h>
  18 #include <video_fb.h>
  19 #include <linux/list.h>
  20 #include <linux/fb.h>
  21
  22 #include <linux/errno.h>
  23 #include <asm/io.h>
  24 #include <asm/arch/hardware.h>
  25
  26 #include "videomodes.h"
  27 #include "da8xx-fb.h"
  28
  29 #if !defined(DA8XX_LCD_CNTL_BASE)
  30 #define DA8XX_LCD_CNTL_BASE     DAVINCI_LCD_CNTL_BASE
  31 #endif
  32
  33 #define DRIVER_NAME "da8xx_lcdc"
  34
  35 #define LCD_VERSION_1   1
  36 #define LCD_VERSION_2   2
  37
  38 /* LCD Status Register */
  39 #define LCD_END_OF_FRAME1               (1 << 9)
  40 #define LCD_END_OF_FRAME0               (1 << 8)
  41 #define LCD_PL_LOAD_DONE                (1 << 6)
  42 #define LCD_FIFO_UNDERFLOW              (1 << 5)
  43 #define LCD_SYNC_LOST                   (1 << 2)
  44
  45 /* LCD DMA Control Register */
  46 #define LCD_DMA_BURST_SIZE(x)           ((x) << 4)
  47 #define LCD_DMA_BURST_1                 0x0
  48 #define LCD_DMA_BURST_2                 0x1
  49 #define LCD_DMA_BURST_4                 0x2
  50 #define LCD_DMA_BURST_8                 0x3
  51 #define LCD_DMA_BURST_16                0x4
  52 #define LCD_V1_END_OF_FRAME_INT_ENA     (1 << 2)
  53 #define LCD_V2_END_OF_FRAME0_INT_ENA    (1 << 8)
  54 #define LCD_V2_END_OF_FRAME1_INT_ENA    (1 << 9)
  55 #define LCD_DUAL_FRAME_BUFFER_ENABLE    (1 << 0)
  56
  57 #define LCD_V2_TFT_24BPP_MODE           (1 << 25)
  58 #define LCD_V2_TFT_24BPP_UNPACK         (1 << 26)
  59
  60 /* LCD Control Register */
  61 #define LCD_CLK_DIVISOR(x)              ((x) << 8)
  62 #define LCD_RASTER_MODE                 0x01
  63
  64 /* LCD Raster Control Register */
  65 #define LCD_PALETTE_LOAD_MODE(x)        ((x) << 20)
  66 #define PALETTE_AND_DATA                0x00
  67 #define PALETTE_ONLY                    0x01
  68 #define DATA_ONLY                       0x02
  69
  70 #define LCD_MONO_8BIT_MODE              (1 << 9)
  71 #define LCD_RASTER_ORDER                (1 << 8)
  72 #define LCD_TFT_MODE                    (1 << 7)
  73 #define LCD_V1_UNDERFLOW_INT_ENA        (1 << 6)
  74 #define LCD_V2_UNDERFLOW_INT_ENA        (1 << 5)
  75 #define LCD_V1_PL_INT_ENA               (1 << 4)
  76 #define LCD_V2_PL_INT_ENA               (1 << 6)
  77 #define LCD_MONOCHROME_MODE             (1 << 1)
  78 #define LCD_RASTER_ENABLE               (1 << 0)
  79 #define LCD_TFT_ALT_ENABLE              (1 << 23)
  80 #define LCD_STN_565_ENABLE              (1 << 24)
  81 #define LCD_V2_DMA_CLK_EN               (1 << 2)
  82 #define LCD_V2_LIDD_CLK_EN              (1 << 1)
  83 #define LCD_V2_CORE_CLK_EN              (1 << 0)
  84 #define LCD_V2_LPP_B10                  26
  85 #define LCD_V2_TFT_24BPP_MODE           (1 << 25)
  86 #define LCD_V2_TFT_24BPP_UNPACK         (1 << 26)
  87
  88 /* LCD Raster Timing 2 Register */
  89 #define LCD_AC_BIAS_TRANSITIONS_PER_INT(x)      ((x) << 16)
  90 #define LCD_AC_BIAS_FREQUENCY(x)                ((x) << 8)
  91 #define LCD_SYNC_CTRL                           (1 << 25)
  92 #define LCD_SYNC_EDGE                           (1 << 24)
  93 #define LCD_INVERT_PIXEL_CLOCK                  (1 << 22)
  94 #define LCD_INVERT_LINE_CLOCK                   (1 << 21)
  95 #define LCD_INVERT_FRAME_CLOCK                  (1 << 20)
  96
  97 /* Clock registers available only on Version 2 */
  98 #define  LCD_CLK_MAIN_RESET                     (1 << 3)
  99 /* LCD Block */
 100 struct da8xx_lcd_regs {
 101         u32     revid;
 102         u32     ctrl;
 103         u32     stat;
 104         u32     lidd_ctrl;
 105         u32     lidd_cs0_conf;
 106         u32     lidd_cs0_addr;
 107         u32     lidd_cs0_data;
 108         u32     lidd_cs1_conf;
 109         u32     lidd_cs1_addr;
 110         u32     lidd_cs1_data;
 111         u32     raster_ctrl;
 112         u32     raster_timing_0;
 113         u32     raster_timing_1;
 114         u32     raster_timing_2;
 115         u32     raster_subpanel;
 116         u32     reserved;
 117         u32     dma_ctrl;
 118         u32     dma_frm_buf_base_addr_0;
 119         u32     dma_frm_buf_ceiling_addr_0;
 120         u32     dma_frm_buf_base_addr_1;
 121         u32     dma_frm_buf_ceiling_addr_1;
 122         u32     resv1;
 123         u32     raw_stat;
 124         u32     masked_stat;
 125         u32     int_ena_set;
 126         u32     int_ena_clr;
 127         u32     end_of_int_ind;
 128         /* Clock registers available only on Version 2 */
 129         u32     clk_ena;
 130         u32     clk_reset;
 131 };
 132
 133 #define LCD_NUM_BUFFERS 1
 134
 135 #define WSI_TIMEOUT     50
 136 #define PALETTE_SIZE    256
 137 #define LEFT_MARGIN     64
 138 #define RIGHT_MARGIN    64
 139 #define UPPER_MARGIN    32
 140 #define LOWER_MARGIN    32
 141 #define WAIT_FOR_FRAME_DONE     true
 142 #define NO_WAIT_FOR_FRAME_DONE  false
 143
 144 #define calc_fbsize() (panel.plnSizeX * panel.plnSizeY * panel.gdfBytesPP)
 145
 146 static struct da8xx_lcd_regs *da8xx_fb_reg_base;
 147
 148 DECLARE_GLOBAL_DATA_PTR;
 149
 150 /* graphics setup */
 151 static GraphicDevice gpanel;
 152 static const struct da8xx_panel *lcd_panel;
 153 static struct fb_info *da8xx_fb_info;
 154 static int bits_x_pixel;
 155 static unsigned int lcd_revision;
 156 const struct lcd_ctrl_config *da8xx_lcd_cfg;
 157
 158 static inline unsigned int lcdc_read(u32 *addr)
 159 {
 160         return (unsigned int)readl(addr);
 161 }
 162
 163 static inline void lcdc_write(unsigned int val, u32 *addr)
 164 {
 165         writel(val, addr);
 166 }
 167
 168 struct da8xx_fb_par {
 169         u32                      p_palette_base;
 170         unsigned char *v_palette_base;
 171         dma_addr_t              vram_phys;
 172         unsigned long           vram_size;
 173         void                    *vram_virt;
 174         unsigned int            dma_start;
 175         unsigned int            dma_end;
 176         struct clk *lcdc_clk;
 177         int irq;
 178         unsigned short pseudo_palette[16];
 179         unsigned int palette_sz;
 180         unsigned int pxl_clk;
 181         int blank;
 182         int                     vsync_flag;
 183         int                     vsync_timeout;
 184 };
 185
 186
 187 /* Variable Screen Information */
 188 static struct fb_var_screeninfo da8xx_fb_var = {
 189         .xoffset = 0,
 190         .yoffset = 0,
 191         .transp = {0, 0, 0},
 192         .nonstd = 0,
 193         .activate = 0,
 194         .height = -1,
 195         .width = -1,
 196         .pixclock = 46666,      /* 46us - AUO display */
 197         .accel_flags = 0,
 198         .left_margin = LEFT_MARGIN,
 199         .right_margin = RIGHT_MARGIN,
 200         .upper_margin = UPPER_MARGIN,
 201         .lower_margin = LOWER_MARGIN,
 202         .sync = 0,
 203         .vmode = FB_VMODE_NONINTERLACED
 204 };
 205
 206 static struct fb_fix_screeninfo da8xx_fb_fix = {
 207         .id = "DA8xx FB Drv",
 208         .type = FB_TYPE_PACKED_PIXELS,
 209         .type_aux = 0,
 210         .visual = FB_VISUAL_PSEUDOCOLOR,
 211         .xpanstep = 0,
 212         .ypanstep = 1,
 213         .ywrapstep = 0,
 214         .accel = FB_ACCEL_NONE
 215 };
 216
 217 /* Enable the Raster Engine of the LCD Controller */
 218 static inline void lcd_enable_raster(void)
 219 {
 220         u32 reg;
 221
 222         /* Put LCDC in reset for several cycles */
 223         if (lcd_revision == LCD_VERSION_2)
 224                 lcdc_write(LCD_CLK_MAIN_RESET,
 225                            &da8xx_fb_reg_base->clk_reset);
 226
 227         udelay(1000);
 228         /* Bring LCDC out of reset */
 229         if (lcd_revision == LCD_VERSION_2)
 230                 lcdc_write(0,
 231                            &da8xx_fb_reg_base->clk_reset);
 232
 233         udelay(1000);
 234
 235         reg = lcdc_read(&da8xx_fb_reg_base->raster_ctrl);
 236         if (!(reg & LCD_RASTER_ENABLE))
 237                 lcdc_write(reg | LCD_RASTER_ENABLE,
 238                         &da8xx_fb_reg_base->raster_ctrl);
 239 }
 240
 241 /* Disable the Raster Engine of the LCD Controller */
 242 static inline void lcd_disable_raster(bool wait_for_frame_done)
 243 {
 244         u32 reg;
 245         u32 loop_cnt = 0;
 246         u32 stat;
 247         u32 i = 0;
 248
 249         if (wait_for_frame_done)
 250                 loop_cnt = 5000;
 251
 252         reg = lcdc_read(&da8xx_fb_reg_base->raster_ctrl);
 253         if (reg & LCD_RASTER_ENABLE)
 254                 lcdc_write(reg & ~LCD_RASTER_ENABLE,
 255                         &da8xx_fb_reg_base->raster_ctrl);
 256
 257         /* Wait for the current frame to complete */
 258         do {
 259                 if (lcd_revision == LCD_VERSION_1)
 260                         stat = lcdc_read(&da8xx_fb_reg_base->stat);
 261                 else
 262                         stat = lcdc_read(&da8xx_fb_reg_base->raw_stat);
 263
 264                 mdelay(1);
 265         } while (!(stat & 0x01) && (i++ < loop_cnt));
 266
 267         if (lcd_revision == LCD_VERSION_1)
 268                 lcdc_write(stat, &da8xx_fb_reg_base->stat);
 269         else
 270                 lcdc_write(stat, &da8xx_fb_reg_base->raw_stat);
 271
 272         if ((loop_cnt != 0) && (i >= loop_cnt)) {
 273                 printf("LCD Controller timed out\n");
 274                 return;
 275         }
 276 }
 277
 278 static void lcd_blit(int load_mode, struct da8xx_fb_par *par)
 279 {
 280         u32 start;
 281         u32 end;
 282         u32 reg_ras;
 283         u32 reg_dma;
 284         u32 reg_int;
 285
 286         /* init reg to clear PLM (loading mode) fields */
 287         reg_ras = lcdc_read(&da8xx_fb_reg_base->raster_ctrl);
 288         reg_ras &= ~(3 << 20);
 289
 290         reg_dma  = lcdc_read(&da8xx_fb_reg_base->dma_ctrl);
 291
 292         if (load_mode == LOAD_DATA) {
 293                 start    = par->dma_start;
 294                 end      = par->dma_end;
 295
 296                 reg_ras |= LCD_PALETTE_LOAD_MODE(DATA_ONLY);
 297                 if (lcd_revision == LCD_VERSION_1) {
 298                         reg_dma |= LCD_V1_END_OF_FRAME_INT_ENA;
 299                 } else {
 300                         reg_int = lcdc_read(&da8xx_fb_reg_base->int_ena_set) |
 301                                 LCD_V2_END_OF_FRAME0_INT_ENA |
 302                                 LCD_V2_END_OF_FRAME1_INT_ENA |
 303                                 LCD_V2_UNDERFLOW_INT_ENA | LCD_SYNC_LOST;
 304                         lcdc_write(reg_int, &da8xx_fb_reg_base->int_ena_set);
 305                 }
 306
 307 #if (LCD_NUM_BUFFERS == 2)
 308                 reg_dma |= LCD_DUAL_FRAME_BUFFER_ENABLE;
 309                 lcdc_write(start, &da8xx_fb_reg_base->dma_frm_buf_base_addr_0);
 310                 lcdc_write(end, &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_0);
 311                 lcdc_write(start, &da8xx_fb_reg_base->dma_frm_buf_base_addr_1);
 312                 lcdc_write(end, &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_1);
 313 #else
 314                 reg_dma &= ~LCD_DUAL_FRAME_BUFFER_ENABLE;
 315                 lcdc_write(start, &da8xx_fb_reg_base->dma_frm_buf_base_addr_0);
 316                 lcdc_write(end, &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_0);
 317                 lcdc_write(0, &da8xx_fb_reg_base->dma_frm_buf_base_addr_1);
 318                 lcdc_write(0, &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_1);
 319 #endif
 320
 321         } else if (load_mode == LOAD_PALETTE) {
 322                 start    = par->p_palette_base;
 323                 end      = start + par->palette_sz - 1;
 324
 325                 reg_ras |= LCD_PALETTE_LOAD_MODE(PALETTE_ONLY);
 326                 if (lcd_revision == LCD_VERSION_1) {
 327                         reg_ras |= LCD_V1_PL_INT_ENA;
 328                 } else {
 329                         reg_int = lcdc_read(&da8xx_fb_reg_base->int_ena_set) |
 330                                 LCD_V2_PL_INT_ENA;
 331                         lcdc_write(reg_int, &da8xx_fb_reg_base->int_ena_set);
 332                 }
 333
 334                 lcdc_write(start, &da8xx_fb_reg_base->dma_frm_buf_base_addr_0);
 335                 lcdc_write(end, &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_0);
 336         }
 337
 338         lcdc_write(reg_dma, &da8xx_fb_reg_base->dma_ctrl);
 339         lcdc_write(reg_ras, &da8xx_fb_reg_base->raster_ctrl);
 340
 341         /*
 342          * The Raster enable bit must be set after all other control fields are
 343          * set.
 344          */
 345         lcd_enable_raster();
 346 }
 347
 348 /* Configure the Burst Size of DMA */
 349 static int lcd_cfg_dma(int burst_size)
 350 {
 351         u32 reg;
 352
 353         reg = lcdc_read(&da8xx_fb_reg_base->dma_ctrl) & 0x00000001;
 354         switch (burst_size) {
 355         case 1:
 356                 reg |= LCD_DMA_BURST_SIZE(LCD_DMA_BURST_1);
 357                 break;
 358         case 2:
 359                 reg |= LCD_DMA_BURST_SIZE(LCD_DMA_BURST_2);
 360                 break;
 361         case 4:
 362                 reg |= LCD_DMA_BURST_SIZE(LCD_DMA_BURST_4);
 363                 break;
 364         case 8:
 365                 reg |= LCD_DMA_BURST_SIZE(LCD_DMA_BURST_8);
 366                 break;
 367         case 16:
 368                 reg |= LCD_DMA_BURST_SIZE(LCD_DMA_BURST_16);
 369                 break;
 370         default:
 371                 return -EINVAL;
 372         }
 373         lcdc_write(reg, &da8xx_fb_reg_base->dma_ctrl);
 374
 375         return 0;
 376 }
 377
 378 static void lcd_cfg_ac_bias(int period, int transitions_per_int)
 379 {
 380         u32 reg;
 381
 382         /* Set the AC Bias Period and Number of Transitions per Interrupt */
 383         reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_2) & 0xFFF00000;
 384         reg |= LCD_AC_BIAS_FREQUENCY(period) |
 385                 LCD_AC_BIAS_TRANSITIONS_PER_INT(transitions_per_int);
 386         lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_2);
 387 }
 388
 389 static void lcd_cfg_horizontal_sync(int back_porch, int pulse_width,
 390                 int front_porch)
 391 {
 392         u32 reg;
 393
 394         reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_0) & 0xf;
 395         reg |= ((back_porch & 0xff) << 24)
 396             | ((front_porch & 0xff) << 16)
 397             | ((pulse_width & 0x3f) << 10);
 398         lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_0);
 399 }
 400
 401 static void lcd_cfg_vertical_sync(int back_porch, int pulse_width,
 402                 int front_porch)
 403 {
 404         u32 reg;
 405
 406         reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_1) & 0x3ff;
 407         reg |= ((back_porch & 0xff) << 24)
 408             | ((front_porch & 0xff) << 16)
 409             | ((pulse_width & 0x3f) << 10);
 410         lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_1);
 411 }
 412
 413 static int lcd_cfg_display(const struct lcd_ctrl_config *cfg)
 414 {
 415         u32 reg;
 416         u32 reg_int;
 417
 418         reg = lcdc_read(&da8xx_fb_reg_base->raster_ctrl) & ~(LCD_TFT_MODE |
 419                                                 LCD_MONO_8BIT_MODE |
 420                                                 LCD_MONOCHROME_MODE);
 421
 422         switch (cfg->p_disp_panel->panel_shade) {
 423         case MONOCHROME:
 424                 reg |= LCD_MONOCHROME_MODE;
 425                 if (cfg->mono_8bit_mode)
 426                         reg |= LCD_MONO_8BIT_MODE;
 427                 break;
 428         case COLOR_ACTIVE:
 429                 reg |= LCD_TFT_MODE;
 430                 if (cfg->tft_alt_mode)
 431                         reg |= LCD_TFT_ALT_ENABLE;
 432                 break;
 433
 434         case COLOR_PASSIVE:
 435                 if (cfg->stn_565_mode)
 436                         reg |= LCD_STN_565_ENABLE;
 437                 break;
 438
 439         default:
 440                 return -EINVAL;
 441         }
 442
 443         /* enable additional interrupts here */
 444         if (lcd_revision == LCD_VERSION_1) {
 445                 reg |= LCD_V1_UNDERFLOW_INT_ENA;
 446         } else {
 447                 reg_int = lcdc_read(&da8xx_fb_reg_base->int_ena_set) |
 448                         LCD_V2_UNDERFLOW_INT_ENA;
 449                 lcdc_write(reg_int, &da8xx_fb_reg_base->int_ena_set);
 450         }
 451
 452         lcdc_write(reg, &da8xx_fb_reg_base->raster_ctrl);
 453
 454         reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_2);
 455
 456         if (cfg->sync_ctrl)
 457                 reg |= LCD_SYNC_CTRL;
 458         else
 459                 reg &= ~LCD_SYNC_CTRL;
 460
 461         if (cfg->sync_edge)
 462                 reg |= LCD_SYNC_EDGE;
 463         else
 464                 reg &= ~LCD_SYNC_EDGE;
 465
 466         if (cfg->invert_line_clock)
 467                 reg |= LCD_INVERT_LINE_CLOCK;
 468         else
 469                 reg &= ~LCD_INVERT_LINE_CLOCK;
 470
 471         if (cfg->invert_frm_clock)
 472                 reg |= LCD_INVERT_FRAME_CLOCK;
 473         else
 474                 reg &= ~LCD_INVERT_FRAME_CLOCK;
 475
 476         lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_2);
 477
 478         return 0;
 479 }
 480
 481 static int lcd_cfg_frame_buffer(struct da8xx_fb_par *par, u32 width, u32 height,
 482                 u32 bpp, u32 raster_order)
 483 {
 484         u32 reg;
 485
 486         /* Set the Panel Width */
 487         /* Pixels per line = (PPL + 1)*16 */
 488         if (lcd_revision == LCD_VERSION_1) {
 489                 /*
 490                  * 0x3F in bits 4..9 gives max horizontal resolution = 1024
 491                  * pixels
 492                  */
 493                 width &= 0x3f0;
 494         } else {
 495                 /*
 496                  * 0x7F in bits 4..10 gives max horizontal resolution = 2048
 497                  * pixels.
 498                  */
 499                 width &= 0x7f0;
 500         }
 501         reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_0);
 502         reg &= 0xfffffc00;
 503         if (lcd_revision == LCD_VERSION_1) {
 504                 reg |= ((width >> 4) - 1) << 4;
 505         } else {
 506                 width = (width >> 4) - 1;
 507                 reg |= ((width & 0x3f) << 4) | ((width & 0x40) >> 3);
 508         }
 509         lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_0);
 510
 511         /* Set the Panel Height */
 512         /* Set bits 9:0 of Lines Per Pixel */
 513         reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_1);
 514         reg = ((height - 1) & 0x3ff) | (reg & 0xfffffc00);
 515         lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_1);
 516
 517         /* Set bit 10 of Lines Per Pixel */
 518         if (lcd_revision == LCD_VERSION_2) {
 519                 reg = lcdc_read(&da8xx_fb_reg_base->raster_timing_2);
 520                 reg |= ((height - 1) & 0x400) << 16;
 521                 lcdc_write(reg, &da8xx_fb_reg_base->raster_timing_2);
 522         }
 523
 524         /* Set the Raster Order of the Frame Buffer */
 525         reg = lcdc_read(&da8xx_fb_reg_base->raster_ctrl) & ~(1 << 8);
 526         if (raster_order)
 527                 reg |= LCD_RASTER_ORDER;
 528
 529         if (bpp == 24)
 530                 reg |= (LCD_TFT_MODE | LCD_V2_TFT_24BPP_MODE);
 531         else if (bpp == 32)
 532                 reg |= (LCD_TFT_MODE | LCD_V2_TFT_24BPP_MODE
 533                                 | LCD_V2_TFT_24BPP_UNPACK);
 534
 535         lcdc_write(reg, &da8xx_fb_reg_base->raster_ctrl);
 536
 537         switch (bpp) {
 538         case 1:
 539         case 2:
 540         case 4:
 541         case 16:
 542         case 24:
 543         case 32:
 544                 par->palette_sz = 16 * 2;
 545                 break;
 546
 547         case 8:
 548                 par->palette_sz = 256 * 2;
 549                 break;
 550
 551         default:
 552                 return -EINVAL;
 553         }
 554
 555         return 0;
 556 }
 557
 558 static int fb_setcolreg(unsigned regno, unsigned red, unsigned green,
 559                               unsigned blue, unsigned transp,
 560                               struct fb_info *info)
 561 {
 562         struct da8xx_fb_par *par = info->par;
 563         unsigned short *palette = (unsigned short *) par->v_palette_base;
 564         u_short pal;
 565         int update_hw = 0;
 566
 567         if (regno > 255)
 568                 return 1;
 569
 570         if (info->fix.visual == FB_VISUAL_DIRECTCOLOR)
 571                 return 1;
 572
 573         if (info->var.bits_per_pixel == 8) {
 574                 red >>= 4;
 575                 green >>= 8;
 576                 blue >>= 12;
 577
 578                 pal = (red & 0x0f00);
 579                 pal |= (green & 0x00f0);
 580                 pal |= (blue & 0x000f);
 581
 582                 if (palette[regno] != pal) {
 583                         update_hw = 1;
 584                         palette[regno] = pal;
 585                 }
 586         } else if ((info->var.bits_per_pixel == 16) && regno < 16) {
 587                 red >>= (16 - info->var.red.length);
 588                 red <<= info->var.red.offset;
 589
 590                 green >>= (16 - info->var.green.length);
 591                 green <<= info->var.green.offset;
 592
 593                 blue >>= (16 - info->var.blue.length);
 594                 blue <<= info->var.blue.offset;
 595
 596                 par->pseudo_palette[regno] = red | green | blue;
 597
 598                 if (palette[0] != 0x4000) {
 599                         update_hw = 1;
 600                         palette[0] = 0x4000;
 601                 }
 602         } else if (((info->var.bits_per_pixel == 32) && regno < 32) ||
 603                    ((info->var.bits_per_pixel == 24) && regno < 24)) {
 604                 red >>= (24 - info->var.red.length);
 605                 red <<= info->var.red.offset;
 606
 607                 green >>= (24 - info->var.green.length);
 608                 green <<= info->var.green.offset;
 609
 610                 blue >>= (24 - info->var.blue.length);
 611                 blue <<= info->var.blue.offset;
 612
 613                 par->pseudo_palette[regno] = red | green | blue;
 614
 615                 if (palette[0] != 0x4000) {
 616                         update_hw = 1;
 617                         palette[0] = 0x4000;
 618                 }
 619         }
 620
 621         /* Update the palette in the h/w as needed. */
 622         if (update_hw)
 623                 lcd_blit(LOAD_PALETTE, par);
 624
 625         return 0;
 626 }
 627
 628 static void lcd_reset(struct da8xx_fb_par *par)
 629 {
 630         /* Disable the Raster if previously Enabled */
 631         lcd_disable_raster(NO_WAIT_FOR_FRAME_DONE);
 632
 633         /* DMA has to be disabled */
 634         lcdc_write(0, &da8xx_fb_reg_base->dma_ctrl);
 635         lcdc_write(0, &da8xx_fb_reg_base->raster_ctrl);
 636
 637         if (lcd_revision == LCD_VERSION_2) {
 638                 lcdc_write(0, &da8xx_fb_reg_base->int_ena_set);
 639                 /* Write 1 to reset */
 640                 lcdc_write(LCD_CLK_MAIN_RESET, &da8xx_fb_reg_base->clk_reset);
 641                 lcdc_write(0, &da8xx_fb_reg_base->clk_reset);
 642         }
 643 }
 644
 645 static void lcd_calc_clk_divider(struct da8xx_fb_par *par)
 646 {
 647         unsigned int lcd_clk, div;
 648
 649         /* Get clock from sysclk2 */
 650         lcd_clk = clk_get(2);
 651
 652         div = lcd_clk / par->pxl_clk;
 653         debug("LCD Clock: %d Divider: %d PixClk: %d\n",
 654               lcd_clk, div, par->pxl_clk);
 655
 656         /* Configure the LCD clock divisor. */
 657         lcdc_write(LCD_CLK_DIVISOR(div) |
 658                         (LCD_RASTER_MODE & 0x1), &da8xx_fb_reg_base->ctrl);
 659
 660         if (lcd_revision == LCD_VERSION_2)
 661                 lcdc_write(LCD_V2_DMA_CLK_EN | LCD_V2_LIDD_CLK_EN |
 662                                 LCD_V2_CORE_CLK_EN,
 663                                 &da8xx_fb_reg_base->clk_ena);
 664 }
 665
 666 static int lcd_init(struct da8xx_fb_par *par, const struct lcd_ctrl_config *cfg,
 667                 const struct da8xx_panel *panel)
 668 {
 669         u32 bpp;
 670         int ret = 0;
 671
 672         lcd_reset(par);
 673
 674         /* Calculate the divider */
 675         lcd_calc_clk_divider(par);
 676
 677         if (panel->invert_pxl_clk)
 678                 lcdc_write((lcdc_read(&da8xx_fb_reg_base->raster_timing_2) |
 679                         LCD_INVERT_PIXEL_CLOCK),
 680                          &da8xx_fb_reg_base->raster_timing_2);
 681         else
 682                 lcdc_write((lcdc_read(&da8xx_fb_reg_base->raster_timing_2) &
 683                         ~LCD_INVERT_PIXEL_CLOCK),
 684                         &da8xx_fb_reg_base->raster_timing_2);
 685
 686         /* Configure the DMA burst size. */
 687         ret = lcd_cfg_dma(cfg->dma_burst_sz);
 688         if (ret < 0)
 689                 return ret;
 690
 691         /* Configure the AC bias properties. */
 692         lcd_cfg_ac_bias(cfg->ac_bias, cfg->ac_bias_intrpt);
 693
 694         /* Configure the vertical and horizontal sync properties. */
 695         lcd_cfg_vertical_sync(panel->vbp, panel->vsw, panel->vfp);
 696         lcd_cfg_horizontal_sync(panel->hbp, panel->hsw, panel->hfp);
 697
 698         /* Configure for display */
 699         ret = lcd_cfg_display(cfg);
 700         if (ret < 0)
 701                 return ret;
 702
 703         if ((QVGA != cfg->p_disp_panel->panel_type) &&
 704             (WVGA != cfg->p_disp_panel->panel_type))
 705                 return -EINVAL;
 706
 707         if (cfg->bpp <= cfg->p_disp_panel->max_bpp &&
 708             cfg->bpp >= cfg->p_disp_panel->min_bpp)
 709                 bpp = cfg->bpp;
 710         else
 711                 bpp = cfg->p_disp_panel->max_bpp;
 712         if (bpp == 12)
 713                 bpp = 16;
 714         ret = lcd_cfg_frame_buffer(par, (unsigned int)panel->width,
 715                                 (unsigned int)panel->height, bpp,
 716                                 cfg->raster_order);
 717         if (ret < 0)
 718                 return ret;
 719
 720         /* Configure FDD */
 721         lcdc_write((lcdc_read(&da8xx_fb_reg_base->raster_ctrl) & 0xfff00fff) |
 722                        (cfg->fdd << 12), &da8xx_fb_reg_base->raster_ctrl);
 723
 724         return 0;
 725 }
 726
 727 static void lcdc_dma_start(void)
 728 {
 729         struct da8xx_fb_par *par = da8xx_fb_info->par;
 730         lcdc_write(par->dma_start,
 731                 &da8xx_fb_reg_base->dma_frm_buf_base_addr_0);
 732         lcdc_write(par->dma_end,
 733                 &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_0);
 734         lcdc_write(0,
 735                 &da8xx_fb_reg_base->dma_frm_buf_base_addr_1);
 736         lcdc_write(0,
 737                 &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_1);
 738 }
 739
 740 static u32 lcdc_irq_handler_rev01(void)
 741 {
 742         struct da8xx_fb_par *par = da8xx_fb_info->par;
 743         u32 stat = lcdc_read(&da8xx_fb_reg_base->stat);
 744         u32 reg_ras;
 745
 746         if ((stat & LCD_SYNC_LOST) && (stat & LCD_FIFO_UNDERFLOW)) {
 747                 debug("LCD_SYNC_LOST\n");
 748                 lcd_disable_raster(NO_WAIT_FOR_FRAME_DONE);
 749                 lcdc_write(stat, &da8xx_fb_reg_base->stat);
 750                 lcd_enable_raster();
 751                 return LCD_SYNC_LOST;
 752         } else if (stat & LCD_PL_LOAD_DONE) {
 753                 debug("LCD_PL_LOAD_DONE\n");
 754                 /*
 755                  * Must disable raster before changing state of any control bit.
 756                  * And also must be disabled before clearing the PL loading
 757                  * interrupt via the following write to the status register. If
 758                  * this is done after then one gets multiple PL done interrupts.
 759                  */
 760                 lcd_disable_raster(NO_WAIT_FOR_FRAME_DONE);
 761
 762                 lcdc_write(stat, &da8xx_fb_reg_base->stat);
 763
 764                 /* Disable PL completion interrupt */
 765                 reg_ras  = lcdc_read(&da8xx_fb_reg_base->raster_ctrl);
 766                 reg_ras &= ~LCD_V1_PL_INT_ENA;
 767                 lcdc_write(reg_ras, &da8xx_fb_reg_base->raster_ctrl);
 768
 769                 /* Setup and start data loading mode */
 770                 lcd_blit(LOAD_DATA, par);
 771                 return LCD_PL_LOAD_DONE;
 772         } else {
 773                 lcdc_write(stat, &da8xx_fb_reg_base->stat);
 774
 775                 if (stat & LCD_END_OF_FRAME0)
 776                         debug("LCD_END_OF_FRAME0\n");
 777
 778                 lcdc_write(par->dma_start,
 779                         &da8xx_fb_reg_base->dma_frm_buf_base_addr_0);
 780                 lcdc_write(par->dma_end,
 781                         &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_0);
 782                 par->vsync_flag = 1;
 783                 return LCD_END_OF_FRAME0;
 784         }
 785         return stat;
 786 }
 787
 788 static u32 lcdc_irq_handler_rev02(void)
 789 {
 790         struct da8xx_fb_par *par = da8xx_fb_info->par;
 791         u32 stat = lcdc_read(&da8xx_fb_reg_base->masked_stat);
 792         u32 reg_int;
 793
 794         if ((stat & LCD_SYNC_LOST) && (stat & LCD_FIFO_UNDERFLOW)) {
 795                 debug("LCD_SYNC_LOST\n");
 796                 lcd_disable_raster(NO_WAIT_FOR_FRAME_DONE);
 797                 lcdc_write(stat, &da8xx_fb_reg_base->masked_stat);
 798                 lcd_enable_raster();
 799                 lcdc_write(0, &da8xx_fb_reg_base->end_of_int_ind);
 800                 return LCD_SYNC_LOST;
 801         } else if (stat & LCD_PL_LOAD_DONE) {
 802                 debug("LCD_PL_LOAD_DONE\n");
 803                 /*
 804                  * Must disable raster before changing state of any control bit.
 805                  * And also must be disabled before clearing the PL loading
 806                  * interrupt via the following write to the status register. If
 807                  * this is done after then one gets multiple PL done interrupts.
 808                  */
 809                 lcd_disable_raster(NO_WAIT_FOR_FRAME_DONE);
 810
 811                 lcdc_write(stat, &da8xx_fb_reg_base->masked_stat);
 812
 813                 /* Disable PL completion interrupt */
 814                 reg_int  = lcdc_read(&da8xx_fb_reg_base->int_ena_clr) |
 815                         (LCD_V2_PL_INT_ENA);
 816                 lcdc_write(reg_int, &da8xx_fb_reg_base->int_ena_clr);
 817
 818                 /* Setup and start data loading mode */
 819                 lcd_blit(LOAD_DATA, par);
 820                 lcdc_write(0, &da8xx_fb_reg_base->end_of_int_ind);
 821                 return LCD_PL_LOAD_DONE;
 822         } else {
 823                 lcdc_write(stat, &da8xx_fb_reg_base->masked_stat);
 824
 825                 if (stat & LCD_END_OF_FRAME0)
 826                         debug("LCD_END_OF_FRAME0\n");
 827
 828                 lcdc_write(par->dma_start,
 829                            &da8xx_fb_reg_base->dma_frm_buf_base_addr_0);
 830                 lcdc_write(par->dma_end,
 831                            &da8xx_fb_reg_base->dma_frm_buf_ceiling_addr_0);
 832                 par->vsync_flag = 1;
 833                 lcdc_write(0, &da8xx_fb_reg_base->end_of_int_ind);
 834                 return LCD_END_OF_FRAME0;
 835         }
 836         lcdc_write(0, &da8xx_fb_reg_base->end_of_int_ind);
 837         return stat;
 838 }
 839
 840 static u32 lcdc_irq_handler(void)
 841 {
 842         if (lcd_revision == LCD_VERSION_1)
 843                 return lcdc_irq_handler_rev01();
 844         else
 845                 return lcdc_irq_handler_rev02();
 846 }
 847
 848 static u32 wait_for_event(u32 event)
 849 {
 850         u32 timeout = 50000;
 851         u32 ret;
 852
 853         do {
 854                 ret = lcdc_irq_handler();
 855                 udelay(1000);
 856         } while (!(ret & event));
 857
 858         if (timeout <= 0) {
 859                 printf("%s: event %d not hit\n", __func__, event);
 860                 return -1;
 861         }
 862
 863         return 0;
 864
 865 }
 866
 867 void *video_hw_init(void)
 868 {
 869         struct da8xx_fb_par *par;
 870         u32 size;
 871         u32 rev;
 872         char *p;
 873
 874         if (!lcd_panel) {
 875                 printf("Display not initialized\n");
 876                 return NULL;
 877         }
 878         gpanel.winSizeX = lcd_panel->width;
 879         gpanel.winSizeY = lcd_panel->height;
 880         gpanel.plnSizeX = lcd_panel->width;
 881         gpanel.plnSizeY = lcd_panel->height;
 882
 883         switch (bits_x_pixel) {
 884         case 32:
 885                 gpanel.gdfBytesPP = 4;
 886                 gpanel.gdfIndex = GDF_32BIT_X888RGB;
 887                 break;
 888         case 24:
 889                 gpanel.gdfBytesPP = 4;
 890                 gpanel.gdfIndex = GDF_32BIT_X888RGB;
 891                 break;
 892         case 16:
 893                 gpanel.gdfBytesPP = 2;
 894                 gpanel.gdfIndex = GDF_16BIT_565RGB;
 895                 break;
 896         default:
 897                 gpanel.gdfBytesPP = 1;
 898                 gpanel.gdfIndex = GDF__8BIT_INDEX;
 899                 break;
 900         }
 901
 902         da8xx_fb_reg_base = (struct da8xx_lcd_regs *)DA8XX_LCD_CNTL_BASE;
 903
 904         /* Determine LCD IP Version */
 905         rev = lcdc_read(&da8xx_fb_reg_base->revid);
 906         switch (rev) {
 907         case 0x4C100102:
 908                 lcd_revision = LCD_VERSION_1;
 909                 break;
 910         case 0x4F200800:
 911         case 0x4F201000:
 912                 lcd_revision = LCD_VERSION_2;
 913                 break;
 914         default:
 915                 printf("Unknown PID Reg value 0x%x, defaulting to LCD revision 1\n",
 916                        rev);
 917                 lcd_revision = LCD_VERSION_1;
 918                 break;
 919         }
 920
 921         debug("rev: 0x%x Resolution: %dx%d %d\n", rev,
 922               gpanel.winSizeX,
 923               gpanel.winSizeY,
 924               da8xx_lcd_cfg->bpp);
 925
 926         size = sizeof(struct fb_info) + sizeof(struct da8xx_fb_par);
 927         da8xx_fb_info = malloc(size);
 928         debug("da8xx_fb_info at %x\n", (unsigned int)da8xx_fb_info);
 929
 930         if (!da8xx_fb_info) {
 931                 printf("Memory allocation failed for fb_info\n");
 932                 return NULL;
 933         }
 934         memset(da8xx_fb_info, 0, size);
 935         p = (char *)da8xx_fb_info;
 936         da8xx_fb_info->par = p +  sizeof(struct fb_info);
 937         debug("da8xx_par at %x\n", (unsigned int)da8xx_fb_info->par);
 938
 939         par = da8xx_fb_info->par;
 940         par->pxl_clk = lcd_panel->pxl_clk;
 941
 942         if (lcd_init(par, da8xx_lcd_cfg, lcd_panel) < 0) {
 943                 printf("lcd_init failed\n");
 944                 goto err_release_fb;
 945         }
 946
 947         /* allocate frame buffer */
 948         par->vram_size = lcd_panel->width * lcd_panel->height *
 949                         da8xx_lcd_cfg->bpp;
 950         par->vram_size = par->vram_size * LCD_NUM_BUFFERS / 8;
 951
 952         par->vram_virt = malloc(par->vram_size);
 953
 954         par->vram_phys = (dma_addr_t) par->vram_virt;
 955         debug("Requesting 0x%x bytes for framebuffer at 0x%x\n",
 956                 (unsigned int)par->vram_size,
 957                 (unsigned int)par->vram_virt);
 958         if (!par->vram_virt) {
 959                 printf("GLCD: malloc for frame buffer failed\n");
 960                 goto err_release_fb;
 961         }
 962         gd->fb_base = (int)par->vram_virt;
 963
 964         gpanel.frameAdrs = (unsigned int)par->vram_virt;
 965         da8xx_fb_info->screen_base = (char *) par->vram_virt;
 966         da8xx_fb_fix.smem_start = gpanel.frameAdrs;
 967         da8xx_fb_fix.smem_len = par->vram_size;
 968         da8xx_fb_fix.line_length = (lcd_panel->width * da8xx_lcd_cfg->bpp) / 8;
 969
 970         par->dma_start = par->vram_phys;
 971         par->dma_end   = par->dma_start + lcd_panel->height *
 972                 da8xx_fb_fix.line_length - 1;
 973
 974         /* allocate palette buffer */
 975         par->v_palette_base = malloc(PALETTE_SIZE);
 976         if (!par->v_palette_base) {
 977                 printf("GLCD: malloc for palette buffer failed\n");
 978                 goto err_release_fb_mem;
 979         }
 980         memset(par->v_palette_base, 0, PALETTE_SIZE);
 981         par->p_palette_base = (unsigned int)par->v_palette_base;
 982
 983         /* Initialize par */
 984         da8xx_fb_info->var.bits_per_pixel = da8xx_lcd_cfg->bpp;
 985
 986         da8xx_fb_var.xres = lcd_panel->width;
 987         da8xx_fb_var.xres_virtual = lcd_panel->width;
 988
 989         da8xx_fb_var.yres         = lcd_panel->height;
 990         da8xx_fb_var.yres_virtual = lcd_panel->height * LCD_NUM_BUFFERS;
 991
 992         da8xx_fb_var.grayscale =
 993             da8xx_lcd_cfg->p_disp_panel->panel_shade == MONOCHROME ? 1 : 0;
 994         da8xx_fb_var.bits_per_pixel = da8xx_lcd_cfg->bpp;
 995
 996         da8xx_fb_var.hsync_len = lcd_panel->hsw;
 997         da8xx_fb_var.vsync_len = lcd_panel->vsw;
 998
 999         /* Initialize fbinfo */
1000         da8xx_fb_info->flags = FBINFO_FLAG_DEFAULT;
1001         da8xx_fb_info->fix = da8xx_fb_fix;
1002         da8xx_fb_info->var = da8xx_fb_var;
1003         da8xx_fb_info->pseudo_palette = par->pseudo_palette;
1004         da8xx_fb_info->fix.visual = (da8xx_fb_info->var.bits_per_pixel <= 8) ?
1005                                 FB_VISUAL_PSEUDOCOLOR : FB_VISUAL_TRUECOLOR;
1006
1007         /* Clear interrupt */
1008         memset((void *)par->vram_virt, 0, par->vram_size);
1009         lcd_disable_raster(NO_WAIT_FOR_FRAME_DONE);
1010         if (lcd_revision == LCD_VERSION_1)
1011                 lcdc_write(0xFFFF, &da8xx_fb_reg_base->stat);
1012         else
1013                 lcdc_write(0xFFFF, &da8xx_fb_reg_base->masked_stat);
1014         debug("Palette at 0x%x size %d\n", par->p_palette_base,
1015                 par->palette_sz);
1016         lcdc_dma_start();
1017
1018         /* Load a default palette */
1019         fb_setcolreg(0, 0, 0, 0, 0xffff, da8xx_fb_info);
1020
1021         /* Check that the palette is loaded */
1022         wait_for_event(LCD_PL_LOAD_DONE);
1023
1024         /* Wait until DMA is working */
1025         wait_for_event(LCD_END_OF_FRAME0);
1026
1027         return (void *)&gpanel;
1028
1029 err_release_fb_mem:
1030         free(par->vram_virt);
1031
1032 err_release_fb:
1033         free(da8xx_fb_info);
1034
1035         return NULL;
1036 }
1037
1038 void da8xx_video_init(const struct da8xx_panel *panel,
1039                       const struct lcd_ctrl_config *lcd_cfg, int bits_pixel)
1040 {
1041         lcd_panel = panel;
1042         da8xx_lcd_cfg = lcd_cfg;
1043         bits_x_pixel = bits_pixel;
1044 }