LXR uboot/arch/powerpc/cpu/mpc8xx/video.c

   1/*
   2 * (C) Copyright 2000
   3 * Paolo Scaffardi, AIRVENT SAM s.p.a - RIMINI(ITALY), arsenio@tin.it
   4 * (C) Copyright 2002
   5 * Wolfgang Denk, wd@denx.de
   6 *
   7 * SPDX-License-Identifier:     GPL-2.0+
   8 */
   9
  10/* #define DEBUG */
  11
  12/************************************************************************/
  13/* ** HEADER FILES                                                      */
  14/************************************************************************/
  15
  16#include <stdarg.h>
  17#include <common.h>
  18#include <config.h>
  19#include <version.h>
  20#include <i2c.h>
  21#include <linux/types.h>
  22#include <stdio_dev.h>
  23
  24#ifdef CONFIG_VIDEO
  25
  26DECLARE_GLOBAL_DATA_PTR;
  27
  28/************************************************************************/
  29/* ** DEBUG SETTINGS                                                    */
  30/************************************************************************/
  31
  32#if 0
  33#define VIDEO_DEBUG_COLORBARS   /* Force colorbars output */
  34#endif
  35
  36/************************************************************************/
  37/* ** VIDEO MODE SETTINGS                                               */
  38/************************************************************************/
  39
  40#if 0
  41#define VIDEO_MODE_EXTENDED             /* Allow screen size bigger than visible area */
  42#define VIDEO_MODE_NTSC
  43#endif
  44
  45#define VIDEO_MODE_PAL
  46
  47#if 0
  48#define VIDEO_BLINK                     /* This enables cursor blinking (under construction) */
  49#endif
  50
  51#define VIDEO_INFO                      /* Show U-Boot information */
  52#define VIDEO_INFO_X            VIDEO_LOGO_WIDTH+8
  53#define VIDEO_INFO_Y            16
  54
  55/************************************************************************/
  56/* ** VIDEO MODE CONSTANTS                                              */
  57/************************************************************************/
  58
  59#ifdef VIDEO_MODE_EXTENDED
  60#define VIDEO_COLS      VIDEO_ACTIVE_COLS
  61#define VIDEO_ROWS      VIDEO_ACTIVE_ROWS
  62#else
  63#define VIDEO_COLS      VIDEO_VISIBLE_COLS
  64#define VIDEO_ROWS      VIDEO_VISIBLE_ROWS
  65#endif
  66
  67#define VIDEO_PIXEL_SIZE        (VIDEO_MODE_BPP/8)
  68#define VIDEO_SIZE              (VIDEO_ROWS*VIDEO_COLS*VIDEO_PIXEL_SIZE)        /* Total size of buffer */
  69#define VIDEO_PIX_BLOCKS        (VIDEO_SIZE >> 2)       /* Number of ints */
  70#define VIDEO_LINE_LEN          (VIDEO_COLS*VIDEO_PIXEL_SIZE)   /* Number of bytes per line */
  71#define VIDEO_BURST_LEN         (VIDEO_COLS/8)
  72
  73#ifdef VIDEO_MODE_YUYV
  74#define VIDEO_BG_COL    0x80D880D8      /* Background color in YUYV format */
  75#else
  76#define VIDEO_BG_COL    0xF8F8F8F8      /* Background color in RGB format */
  77#endif
  78
  79/************************************************************************/
  80/* ** FONT AND LOGO DATA                                                */
  81/************************************************************************/
  82
  83#include <video_font.h>                 /* Get font data, width and height */
  84
  85#ifdef CONFIG_VIDEO_LOGO
  86#include <video_logo.h>                 /* Get logo data, width and height */
  87
  88#define VIDEO_LOGO_WIDTH        DEF_U_BOOT_LOGO_WIDTH
  89#define VIDEO_LOGO_HEIGHT       DEF_U_BOOT_LOGO_HEIGHT
  90#define VIDEO_LOGO_ADDR         &u_boot_logo
  91#endif
  92
  93/************************************************************************/
  94/* ** VIDEO CONTROLLER CONSTANTS                                        */
  95/************************************************************************/
  96
  97/* VCCR - VIDEO CONTROLLER CONFIGURATION REGISTER */
  98
  99#define VIDEO_VCCR_VON  0               /* Video controller ON */
 100#define VIDEO_VCCR_CSRC 1               /* Clock source */
 101#define VIDEO_VCCR_PDF  13              /* Pixel display format */
 102#define VIDEO_VCCR_IEN  11              /* Interrupt enable */
 103
 104/* VSR - VIDEO STATUS REGISTER */
 105
 106#define VIDEO_VSR_CAS   6               /* Active set */
 107#define VIDEO_VSR_EOF   0               /* End of frame */
 108
 109/* VCMR - VIDEO COMMAND REGISTER */
 110
 111#define VIDEO_VCMR_BD   0               /* Blank display */
 112#define VIDEO_VCMR_ASEL 1               /* Active set selection */
 113
 114/* VBCB - VIDEO BACKGROUND COLOR BUFFER REGISTER */
 115
 116#define VIDEO_BCSR4_RESET_BIT   21      /* BCSR4 - Extern video encoder reset */
 117#define VIDEO_BCSR4_EXTCLK_BIT  22      /* BCSR4 - Extern clock enable */
 118#define VIDEO_BCSR4_VIDLED_BIT  23      /* BCSR4 - Video led disable */
 119
 120/************************************************************************/
 121/* ** CONSOLE CONSTANTS                                                 */
 122/************************************************************************/
 123
 124#ifdef  CONFIG_VIDEO_LOGO
 125#define CONSOLE_ROWS            ((VIDEO_ROWS - VIDEO_LOGO_HEIGHT) / VIDEO_FONT_HEIGHT)
 126#define VIDEO_LOGO_SKIP         (VIDEO_COLS - VIDEO_LOGO_WIDTH)
 127#else
 128#define CONSOLE_ROWS            (VIDEO_ROWS / VIDEO_FONT_HEIGHT)
 129#endif
 130
 131#define CONSOLE_COLS            (VIDEO_COLS / VIDEO_FONT_WIDTH)
 132#define CONSOLE_ROW_SIZE        (VIDEO_FONT_HEIGHT * VIDEO_LINE_LEN)
 133#define CONSOLE_ROW_FIRST       (video_console_address)
 134#define CONSOLE_ROW_SECOND      (video_console_address + CONSOLE_ROW_SIZE)
 135#define CONSOLE_ROW_LAST        (video_console_address + CONSOLE_SIZE - CONSOLE_ROW_SIZE)
 136#define CONSOLE_SIZE            (CONSOLE_ROW_SIZE * CONSOLE_ROWS)
 137#define CONSOLE_SCROLL_SIZE     (CONSOLE_SIZE - CONSOLE_ROW_SIZE)
 138
 139/*
 140 * Simple color definitions
 141 */
 142#define CONSOLE_COLOR_BLACK      0
 143#define CONSOLE_COLOR_RED        1
 144#define CONSOLE_COLOR_GREEN      2
 145#define CONSOLE_COLOR_YELLOW     3
 146#define CONSOLE_COLOR_BLUE       4
 147#define CONSOLE_COLOR_MAGENTA    5
 148#define CONSOLE_COLOR_CYAN       6
 149#define CONSOLE_COLOR_GREY      13
 150#define CONSOLE_COLOR_GREY2     14
 151#define CONSOLE_COLOR_WHITE     15      /* Must remain last / highest */
 152
 153/************************************************************************/
 154/* ** BITOPS MACROS                                                     */
 155/************************************************************************/
 156
 157#define HISHORT(i)      ((i >> 16)&0xffff)
 158#define LOSHORT(i)      (i & 0xffff)
 159#define HICHAR(s)       ((i >> 8)&0xff)
 160#define LOCHAR(s)       (i & 0xff)
 161#define HI(c)           ((c >> 4)&0xf)
 162#define LO(c)           (c & 0xf)
 163#define SWAPINT(i)      (HISHORT(i) | (LOSHORT(i) << 16))
 164#define SWAPSHORT(s)    (HICHAR(s) | (LOCHAR(s) << 8))
 165#define SWAPCHAR(c)     (HI(c) | (LO(c) << 4))
 166#define BITMASK(b)      (1 << (b))
 167#define GETBIT(v,b)     (((v) & BITMASK(b)) > 0)
 168#define SETBIT(v,b,d)   (v = (((d)>0) ? (v) | BITMASK(b): (v) & ~BITMASK(b)))
 169
 170/************************************************************************/
 171/* ** STRUCTURES                                                        */
 172/************************************************************************/
 173
 174typedef struct {
 175        unsigned char V, Y1, U, Y2;
 176} tYUYV;
 177
 178/* This structure is based on the Video Ram in the MPC823. */
 179typedef struct VRAM {
 180        unsigned        hx:2,           /* Horizontal sync */
 181                        vx:2,           /* Vertical sync */
 182                        fx:2,           /* Frame */
 183                        bx:2,           /* Blank */
 184                        res1:6,         /* Reserved */
 185                        vds:2,          /* Video Data Select */
 186                        inter:1,        /* Interrupt */
 187                        res2:2,         /* Reserved */
 188                        lcyc:11,        /* Loop/video cycles */
 189                        lp:1,           /* Loop start/end */
 190                        lst:1;          /* Last entry */
 191} VRAM;
 192
 193/************************************************************************/
 194/* ** VARIABLES                                                         */
 195/************************************************************************/
 196
 197static int
 198        video_panning_range_x = 0,      /* Video mode invisible pixels x range */
 199        video_panning_range_y = 0,      /* Video mode invisible pixels y range */
 200        video_panning_value_x = 0,      /* Video mode x panning value (absolute) */
 201        video_panning_value_y = 0,      /* Video mode y panning value (absolute) */
 202        video_panning_factor_x = 0,     /* Video mode x panning value (-127 +127) */
 203        video_panning_factor_y = 0,     /* Video mode y panning value (-127 +127) */
 204        console_col = 0,                /* Cursor col */
 205        console_row = 0,                /* Cursor row */
 206        video_palette[16];              /* Our palette */
 207
 208static const int video_font_draw_table[] =
 209        { 0x00000000, 0x0000ffff, 0xffff0000, 0xffffffff };
 210
 211static char
 212        video_color_fg = 0,             /* Current fg color index (0-15) */
 213        video_color_bg = 0,             /* Current bg color index (0-15) */
 214        video_enable = 0;               /* Video has been initialized? */
 215
 216static void
 217        *video_fb_address,              /* Frame buffer address */
 218        *video_console_address;         /* Console frame buffer start address */
 219
 220/************************************************************************/
 221/* ** MEMORY FUNCTIONS (32bit)                                          */
 222/************************************************************************/
 223
 224static void memsetl (int *p, int c, int v)
 225{
 226        while (c--)
 227                *(p++) = v;
 228}
 229
 230static void memcpyl (int *d, int *s, int c)
 231{
 232        while (c--)
 233                *(d++) = *(s++);
 234}
 235
 236/************************************************************************/
 237/* ** VIDEO DRAWING AND COLOR FUNCTIONS                                 */
 238/************************************************************************/
 239
 240static int video_maprgb (int r, int g, int b)
 241{
 242#ifdef VIDEO_MODE_YUYV
 243        unsigned int pR, pG, pB;
 244        tYUYV YUYV;
 245        unsigned int *ret = (unsigned int *) &YUYV;
 246
 247        /* Transform (0-255) components to (0-100) */
 248
 249        pR = r * 100 / 255;
 250        pG = g * 100 / 255;
 251        pB = b * 100 / 255;
 252
 253        /* Calculate YUV values (0-255) from RGB beetween 0-100 */
 254
 255        YUYV.Y1 = YUYV.Y2 = 209 * (pR + pG + pB) / 300 + 16;
 256        YUYV.U  = pR - (pG * 3 / 4) - (pB / 4) + 128;
 257        YUYV.V  = pB - (pR / 4) - (pG * 3 / 4) + 128;
 258        return *ret;
 259#endif
 260#ifdef VIDEO_MODE_RGB
 261        return ((r >> 3) << 11) | ((g > 2) << 6) | (b >> 3);
 262#endif
 263}
 264
 265static void video_setpalette (int color, int r, int g, int b)
 266{
 267        color &= 0xf;
 268
 269        video_palette[color] = video_maprgb (r, g, b);
 270
 271        /* Swap values if our panning offset is odd */
 272        if (video_panning_value_x & 1)
 273                video_palette[color] = SWAPINT (video_palette[color]);
 274}
 275
 276static void video_fill (int color)
 277{
 278        memsetl (video_fb_address, VIDEO_PIX_BLOCKS, color);
 279}
 280
 281static void video_setfgcolor (int i)
 282{
 283        video_color_fg = i & 0xf;
 284}
 285
 286static void video_setbgcolor (int i)
 287{
 288        video_color_bg = i & 0xf;
 289}
 290
 291static int video_pickcolor (int i)
 292{
 293        return video_palette[i & 0xf];
 294}
 295
 296/* Absolute console plotting functions */
 297
 298#ifdef VIDEO_BLINK
 299static void video_revchar (int xx, int yy)
 300{
 301        int rows;
 302        u8 *dest;
 303
 304        dest = video_fb_address + yy * VIDEO_LINE_LEN + xx * 2;
 305
 306        for (rows = VIDEO_FONT_HEIGHT; rows--; dest += VIDEO_LINE_LEN) {
 307                switch (VIDEO_FONT_WIDTH) {
 308                case 16:
 309                        ((u32 *) dest)[6] ^= 0xffffffff;
 310                        ((u32 *) dest)[7] ^= 0xffffffff;
 311                        /* FALL THROUGH */
 312                case 12:
 313                        ((u32 *) dest)[4] ^= 0xffffffff;
 314                        ((u32 *) dest)[5] ^= 0xffffffff;
 315                        /* FALL THROUGH */
 316                case 8:
 317                        ((u32 *) dest)[2] ^= 0xffffffff;
 318                        ((u32 *) dest)[3] ^= 0xffffffff;
 319                        /* FALL THROUGH */
 320                case 4:
 321                        ((u32 *) dest)[0] ^= 0xffffffff;
 322                        ((u32 *) dest)[1] ^= 0xffffffff;
 323                }
 324        }
 325}
 326#endif
 327
 328static void video_drawchars (int xx, int yy, unsigned char *s, int count)
 329{
 330        u8 *cdat, *dest, *dest0;
 331        int rows, offset, c;
 332        u32 eorx, fgx, bgx;
 333
 334        offset = yy * VIDEO_LINE_LEN + xx * 2;
 335        dest0 = video_fb_address + offset;
 336
 337        fgx = video_pickcolor (video_color_fg);
 338        bgx = video_pickcolor (video_color_bg);
 339
 340        if (xx & 1) {
 341                fgx = SWAPINT (fgx);
 342                bgx = SWAPINT (bgx);
 343        }
 344
 345        eorx = fgx ^ bgx;
 346
 347        switch (VIDEO_FONT_WIDTH) {
 348        case 4:
 349        case 8:
 350                while (count--) {
 351                        c = *s;
 352                        cdat = video_fontdata + c * VIDEO_FONT_HEIGHT;
 353                        for (rows = VIDEO_FONT_HEIGHT, dest = dest0;
 354                             rows--;
 355                             dest += VIDEO_LINE_LEN) {
 356                                u8 bits = *cdat++;
 357
 358                                ((u32 *) dest)[0] =
 359                                        (video_font_draw_table[bits >> 6] & eorx) ^ bgx;
 360                                ((u32 *) dest)[1] =
 361                                        (video_font_draw_table[bits >> 4 & 3] & eorx) ^ bgx;
 362                                if (VIDEO_FONT_WIDTH == 8) {
 363                                        ((u32 *) dest)[2] =
 364                                                (video_font_draw_table[bits >> 2 & 3] & eorx) ^ bgx;
 365                                        ((u32 *) dest)[3] =
 366                                                (video_font_draw_table[bits & 3] & eorx) ^ bgx;
 367                                }
 368                        }
 369                        dest0 += VIDEO_FONT_WIDTH * 2;
 370                        s++;
 371                }
 372                break;
 373        case 12:
 374        case 16:
 375                while (count--) {
 376                        cdat = video_fontdata + (*s) * (VIDEO_FONT_HEIGHT << 1);
 377                        for (rows = VIDEO_FONT_HEIGHT, dest = dest0; rows--;
 378                                 dest += VIDEO_LINE_LEN) {
 379                                u8 bits = *cdat++;
 380
 381                                ((u32 *) dest)[0] =
 382                                        (video_font_draw_table[bits >> 6] & eorx) ^ bgx;
 383                                ((u32 *) dest)[1] =
 384                                        (video_font_draw_table[bits >> 4 & 3] & eorx) ^ bgx;
 385                                ((u32 *) dest)[2] =
 386                                        (video_font_draw_table[bits >> 2 & 3] & eorx) ^ bgx;
 387                                ((u32 *) dest)[3] =
 388                                        (video_font_draw_table[bits & 3] & eorx) ^ bgx;
 389                                bits = *cdat++;
 390                                ((u32 *) dest)[4] =
 391                                        (video_font_draw_table[bits >> 6] & eorx) ^ bgx;
 392                                ((u32 *) dest)[5] =
 393                                        (video_font_draw_table[bits >> 4 & 3] & eorx) ^ bgx;
 394                                if (VIDEO_FONT_WIDTH == 16) {
 395                                        ((u32 *) dest)[6] =
 396                                                (video_font_draw_table[bits >> 2 & 3] & eorx) ^ bgx;
 397                                        ((u32 *) dest)[7] =
 398                                                (video_font_draw_table[bits & 3] & eorx) ^ bgx;
 399                                }
 400                        }
 401                        s++;
 402                        dest0 += VIDEO_FONT_WIDTH * 2;
 403                }
 404                break;
 405        }
 406}
 407
 408static inline void video_drawstring (int xx, int yy, char *s)
 409{
 410        video_drawchars (xx, yy, (unsigned char *)s, strlen (s));
 411}
 412
 413/* Relative to console plotting functions */
 414
 415static void video_putchars (int xx, int yy, unsigned char *s, int count)
 416{
 417#ifdef CONFIG_VIDEO_LOGO
 418        video_drawchars (xx, yy + VIDEO_LOGO_HEIGHT, s, count);
 419#else
 420        video_drawchars (xx, yy, s, count);
 421#endif
 422}
 423
 424static void video_putchar (int xx, int yy, unsigned char c)
 425{
 426#ifdef CONFIG_VIDEO_LOGO
 427        video_drawchars (xx, yy + VIDEO_LOGO_HEIGHT, &c, 1);
 428#else
 429        video_drawchars (xx, yy, &c, 1);
 430#endif
 431}
 432
 433static inline void video_putstring (int xx, int yy, unsigned char *s)
 434{
 435        video_putchars (xx, yy, (unsigned char *)s, strlen ((char *)s));
 436}
 437
 438/************************************************************************/
 439/* ** VIDEO CONTROLLER LOW-LEVEL FUNCTIONS                              */
 440/************************************************************************/
 441
 442static void video_mode_dupefield (VRAM * source, VRAM * dest, int entries)
 443{
 444        int i;
 445
 446        for (i = 0; i < entries; i++) {
 447                dest[i] = source[i];    /* Copy the entire record */
 448                dest[i].fx = (!dest[i].fx) * 3; /* Negate field bit */
 449        }
 450
 451        dest[0].lcyc++;                 /* Add a cycle to the first entry */
 452        dest[entries - 1].lst = 1;      /* Set end of ram entries */
 453}
 454
 455static void inline video_mode_addentry (VRAM * vr,
 456        int Hx, int Vx, int Fx, int Bx,
 457        int VDS, int INT, int LCYC, int LP, int LST)
 458{
 459        vr->hx = Hx;
 460        vr->vx = Vx;
 461        vr->fx = Fx;
 462        vr->bx = Bx;
 463        vr->vds = VDS;
 464        vr->inter = INT;
 465        vr->lcyc = LCYC;
 466        vr->lp = LP;
 467        vr->lst = LST;
 468}
 469
 470#define ADDENTRY(a,b,c,d,e,f,g,h,i)     video_mode_addentry(&vr[entry++],a,b,c,d,e,f,g,h,i)
 471
 472static int video_mode_generate (void)
 473{
 474        immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 475        VRAM *vr = (VRAM *) (((void *) immap) + 0xb00); /* Pointer to the VRAM table */
 476        int DX, X1, X2, DY, Y1, Y2, entry = 0, fifo;
 477
 478        /* CHECKING PARAMETERS */
 479
 480        if (video_panning_factor_y < -128)
 481                video_panning_factor_y = -128;
 482
 483        if (video_panning_factor_y > 128)
 484                video_panning_factor_y = 128;
 485
 486        if (video_panning_factor_x < -128)
 487                video_panning_factor_x = -128;
 488
 489        if (video_panning_factor_x > 128)
 490                video_panning_factor_x = 128;
 491
 492        /* Setting panning */
 493
 494        DX = video_panning_range_x = (VIDEO_ACTIVE_COLS - VIDEO_COLS) * 2;
 495        DY = video_panning_range_y = (VIDEO_ACTIVE_ROWS - VIDEO_ROWS) / 2;
 496
 497        video_panning_value_x = (video_panning_factor_x + 128) * DX / 256;
 498        video_panning_value_y = (video_panning_factor_y + 128) * DY / 256;
 499
 500        /* We assume these are burst units (multiplied by 2, we need it pari) */
 501        X1 = video_panning_value_x & 0xfffe;
 502        X2 = DX - X1;
 503
 504        /* We assume these are field line units (divided by 2, we need it pari) */
 505        Y1 = video_panning_value_y & 0xfffe;
 506        Y2 = DY - Y1;
 507
 508        debug("X1=%d, X2=%d, Y1=%d, Y2=%d, DX=%d, DY=%d VIDEO_COLS=%d \n",
 509              X1, X2, Y1, Y2, DX, DY, VIDEO_COLS);
 510
 511#ifdef VIDEO_MODE_NTSC
 512/*
 513 *           Hx Vx Fx Bx VDS INT LCYC LP LST
 514 *
 515 * Retrace blanking
 516 */
 517        ADDENTRY (0, 0, 3, 0, 1, 0, 3, 1, 0);
 518        ADDENTRY (3, 0, 3, 0, 1, 0, 243, 0, 0);
 519        ADDENTRY (3, 0, 3, 0, 1, 0, 1440, 0, 0);
 520        ADDENTRY (3, 0, 3, 0, 1, 0, 32, 1, 0);
 521/*
 522 * Vertical blanking
 523 */
 524        ADDENTRY (0, 0, 0, 0, 1, 0, 18, 1, 0);
 525        ADDENTRY (3, 0, 0, 0, 1, 0, 243, 0, 0);
 526        ADDENTRY (3, 0, 0, 0, 1, 0, 1440, 0, 0);
 527        ADDENTRY (3, 0, 0, 0, 1, 0, 32, 1, 0);
 528/*
 529 * Odd field active area (TOP)
 530 */
 531        if (Y1 > 0) {
 532                ADDENTRY (0, 0, 0, 0, 1, 0, Y1, 1, 0);
 533                ADDENTRY (3, 0, 0, 0, 1, 0, 235, 0, 0);
 534                ADDENTRY (3, 0, 0, 3, 1, 0, 1448, 0, 0);
 535                ADDENTRY (3, 0, 0, 0, 1, 0, 32, 1, 0);
 536        }
 537/*
 538 * Odd field active area
 539 */
 540        ADDENTRY (0, 0, 0, 0, 1, 0, 240 - DY, 1, 0);
 541        ADDENTRY (3, 0, 0, 0, 1, 0, 235, 0, 0);
 542        ADDENTRY (3, 0, 0, 3, 1, 0, 8 + X1, 0, 0);
 543        ADDENTRY (3, 0, 0, 3, 0, 0, VIDEO_COLS * 2, 0, 0);
 544
 545        if (X2 > 0)
 546                ADDENTRY (3, 0, 0, 3, 1, 0, X2, 0, 0);
 547
 548        ADDENTRY (3, 0, 0, 0, 1, 0, 32, 1, 0);
 549
 550/*
 551 * Odd field active area (BOTTOM)
 552 */
 553        if (Y1 > 0) {
 554                ADDENTRY (0, 0, 0, 0, 1, 0, Y2, 1, 0);
 555                ADDENTRY (3, 0, 0, 0, 1, 0, 235, 0, 0);
 556                ADDENTRY (3, 0, 0, 3, 1, 0, 1448, 0, 0);
 557                ADDENTRY (3, 0, 0, 0, 1, 0, 32, 1, 0);
 558        }
 559/*
 560 * Vertical blanking
 561 */
 562        ADDENTRY (0, 0, 0, 0, 1, 0, 4, 1, 0);
 563        ADDENTRY (3, 0, 0, 0, 1, 0, 243, 0, 0);
 564        ADDENTRY (3, 0, 0, 0, 1, 0, 1440, 0, 0);
 565        ADDENTRY (3, 0, 0, 0, 1, 0, 32, 1, 0);
 566/*
 567 * Vertical blanking
 568 */
 569        ADDENTRY (0, 0, 3, 0, 1, 0, 19, 1, 0);
 570        ADDENTRY (3, 0, 3, 0, 1, 0, 243, 0, 0);
 571        ADDENTRY (3, 0, 3, 0, 1, 0, 1440, 0, 0);
 572        ADDENTRY (3, 0, 3, 0, 1, 0, 32, 1, 0);
 573/*
 574 * Even field active area (TOP)
 575 */
 576        if (Y1 > 0) {
 577                ADDENTRY (0, 0, 3, 0, 1, 0, Y1, 1, 0);
 578                ADDENTRY (3, 0, 3, 0, 1, 0, 235, 0, 0);
 579                ADDENTRY (3, 0, 3, 3, 1, 0, 1448, 0, 0);
 580                ADDENTRY (3, 0, 3, 0, 1, 0, 32, 1, 0);
 581        }
 582/*
 583 * Even field active area (CENTER)
 584 */
 585        ADDENTRY (0, 0, 3, 0, 1, 0, 240 - DY, 1, 0);
 586        ADDENTRY (3, 0, 3, 0, 1, 0, 235, 0, 0);
 587        ADDENTRY (3, 0, 3, 3, 1, 0, 8 + X1, 0, 0);
 588        ADDENTRY (3, 0, 3, 3, 0, 0, VIDEO_COLS * 2, 0, 0);
 589
 590        if (X2 > 0)
 591                ADDENTRY (3, 0, 3, 3, 1, 0, X2, 0, 0);
 592
 593        ADDENTRY (3, 0, 3, 0, 1, 0, 32, 1, 0);
 594/*
 595 * Even field active area (BOTTOM)
 596 */
 597        if (Y1 > 0) {
 598                ADDENTRY (0, 0, 3, 0, 1, 0, Y2, 1, 0);
 599                ADDENTRY (3, 0, 3, 0, 1, 0, 235, 0, 0);
 600                ADDENTRY (3, 0, 3, 3, 1, 0, 1448, 0, 0);
 601                ADDENTRY (3, 0, 3, 0, 1, 0, 32, 1, 0);
 602        }
 603/*
 604 * Vertical blanking
 605 */
 606        ADDENTRY (0, 0, 3, 0, 1, 0, 1, 1, 0);
 607        ADDENTRY (3, 0, 3, 0, 1, 0, 243, 0, 0);
 608        ADDENTRY (3, 0, 3, 0, 1, 0, 1440, 0, 0);
 609        ADDENTRY (3, 0, 3, 0, 1, 1, 32, 1, 1);
 610#endif
 611
 612#ifdef VIDEO_MODE_PAL
 613
 614/*
 615 *      Hx Vx Fx Bx VDS INT LCYC LP LST
 616 *
 617 * vertical; blanking
 618 */
 619        ADDENTRY (0, 0, 0, 0, 1, 0, 22, 1, 0);
 620        ADDENTRY (3, 0, 0, 0, 1, 0, 263, 0, 0);
 621        ADDENTRY (3, 0, 0, 0, 1, 0, 1440, 0, 0);
 622        ADDENTRY (3, 0, 0, 0, 1, 0, 24, 1, 0);
 623/*
 624 * active area (TOP)
 625 */
 626        if (Y1 > 0) {
 627                ADDENTRY (0, 0, 0, 0, 1, 0, Y1, 1, 0);  /* 11? */
 628                ADDENTRY (3, 0, 0, 0, 1, 0, 255, 0, 0);
 629                ADDENTRY (3, 0, 0, 3, 1, 0, 1448, 0, 0);
 630                ADDENTRY (3, 0, 0, 0, 1, 0, 24, 1, 0);
 631        }
 632/*
 633 * field active area (CENTER)
 634 */
 635        ADDENTRY (0, 0, 0, 0, 1, 0, 288 - DY, 1, 0);    /* 265? */
 636        ADDENTRY (3, 0, 0, 0, 1, 0, 255, 0, 0);
 637        ADDENTRY (3, 0, 0, 3, 1, 0, 8 + X1, 0, 0);
 638        ADDENTRY (3, 0, 0, 3, 0, 0, VIDEO_COLS * 2, 0, 0);
 639
 640        if (X2 > 0)
 641                ADDENTRY (3, 0, 0, 1, 1, 0, X2, 0, 0);
 642
 643        ADDENTRY (3, 0, 0, 0, 1, 0, 24, 1, 0);
 644/*
 645 * field active area (BOTTOM)
 646 */
 647        if (Y2 > 0) {
 648                ADDENTRY (0, 0, 0, 0, 1, 0, Y2, 1, 0);  /* 12? */
 649                ADDENTRY (3, 0, 0, 0, 1, 0, 255, 0, 0);
 650                ADDENTRY (3, 0, 0, 3, 1, 0, 1448, 0, 0);
 651                ADDENTRY (3, 0, 0, 0, 1, 0, 24, 1, 0);
 652        }
 653/*
 654 * field vertical; blanking
 655 */
 656        ADDENTRY (0, 0, 0, 0, 1, 0, 2, 1, 0);
 657        ADDENTRY (3, 0, 0, 0, 1, 0, 263, 0, 0);
 658        ADDENTRY (3, 0, 0, 0, 1, 0, 1440, 0, 0);
 659        ADDENTRY (3, 0, 0, 0, 1, 0, 24, 1, 0);
 660/*
 661 * Create the other field (like this, but whit other field selected,
 662 * one more cycle loop and a last identifier)
 663 */
 664        video_mode_dupefield (vr, &vr[entry], entry);
 665
 666#endif /* VIDEO_MODE_PAL */
 667
 668        /* See what FIFO are we using */
 669        fifo = GETBIT (immap->im_vid.vid_vsr, VIDEO_VSR_CAS);
 670
 671        /* Set number of lines and burst (only one frame for now) */
 672        if (fifo) {
 673                immap->im_vid.vid_vfcr0 = VIDEO_BURST_LEN |
 674                        (VIDEO_BURST_LEN << 8) | ((VIDEO_ROWS / 2) << 19);
 675        } else {
 676                immap->im_vid.vid_vfcr1 = VIDEO_BURST_LEN |
 677                        (VIDEO_BURST_LEN << 8) | ((VIDEO_ROWS / 2) << 19);
 678        }
 679
 680        SETBIT (immap->im_vid.vid_vcmr, VIDEO_VCMR_ASEL, !fifo);
 681
 682/*
 683 * Wait until changes are applied (not done)
 684 * while (GETBIT(immap->im_vid.vid_vsr, VIDEO_VSR_CAS) == fifo) ;
 685 */
 686
 687        /* Return number of VRAM entries */
 688        return entry * 2;
 689}
 690
 691static void video_encoder_init (void)
 692{
 693        return;
 694}
 695
 696static void video_ctrl_init (void *memptr)
 697{
 698        immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 699
 700        video_fb_address = memptr;
 701
 702        /* Set background */
 703        debug ("[VIDEO CTRL] Setting background color...\n");
 704        immap->im_vid.vid_vbcb = VIDEO_BG_COL;
 705
 706        /* Show the background */
 707        debug ("[VIDEO CTRL] Forcing background...\n");
 708        SETBIT (immap->im_vid.vid_vcmr, VIDEO_VCMR_BD, 1);
 709
 710        /* Turn off video controller */
 711        debug ("[VIDEO CTRL] Turning off video controller...\n");
 712        SETBIT (immap->im_vid.vid_vccr, VIDEO_VCCR_VON, 0);
 713
 714        /* Generate and make active a new video mode */
 715        debug ("[VIDEO CTRL] Generating video mode...\n");
 716        video_mode_generate ();
 717
 718        /* Start of frame buffer (even and odd frame, to make it working with */
 719        /* any selected active set) */
 720        debug ("[VIDEO CTRL] Setting frame buffer address...\n");
 721        immap->im_vid.vid_vfaa1 =
 722                immap->im_vid.vid_vfaa0 = (u32) video_fb_address;
 723        immap->im_vid.vid_vfba1 =
 724        immap->im_vid.vid_vfba0 =
 725                (u32) video_fb_address + VIDEO_LINE_LEN;
 726
 727        /* YUV, Big endian, SHIFT/CLK/CLK input (BEFORE ENABLING 27MHZ EXT CLOCK) */
 728        debug ("[VIDEO CTRL] Setting pixel mode and clocks...\n");
 729        immap->im_vid.vid_vccr = 0x2042;
 730
 731        /* Configure port pins */
 732        debug ("[VIDEO CTRL] Configuring input/output pins...\n");
 733        immap->im_ioport.iop_pdpar = 0x1fff;
 734        immap->im_ioport.iop_pddir = 0x0000;
 735
 736        /* Blanking the screen. */
 737        debug ("[VIDEO CTRL] Blanking the screen...\n");
 738        video_fill (VIDEO_BG_COL);
 739
 740        /*
 741         * Turns on Aggressive Mode. Normally, turning on the caches
 742         * will cause the screen to flicker when the caches try to
 743         * fill. This gives the FIFO's for the Video Controller
 744         * higher priority and prevents flickering because of
 745         * underrun. This may still be an issue when using FLASH,
 746         * since accessing data from Flash is so slow.
 747         */
 748        debug ("[VIDEO CTRL] Turning on aggressive mode...\n");
 749        immap->im_siu_conf.sc_sdcr = 0x40;
 750
 751        /* Turn on video controller */
 752        debug ("[VIDEO CTRL] Turning on video controller...\n");
 753        SETBIT (immap->im_vid.vid_vccr, VIDEO_VCCR_VON, 1);
 754
 755        /* Show the display */
 756        debug ("[VIDEO CTRL] Enabling the video...\n");
 757        SETBIT (immap->im_vid.vid_vcmr, VIDEO_VCMR_BD, 0);
 758}
 759
 760/************************************************************************/
 761/* ** CONSOLE FUNCTIONS                                                 */
 762/************************************************************************/
 763
 764static void console_scrollup (void)
 765{
 766        /* Copy up rows ignoring the first one */
 767        memcpyl (CONSOLE_ROW_FIRST, CONSOLE_ROW_SECOND, CONSOLE_SCROLL_SIZE >> 2);
 768
 769        /* Clear the last one */
 770        memsetl (CONSOLE_ROW_LAST, CONSOLE_ROW_SIZE >> 2, VIDEO_BG_COL);
 771}
 772
 773static inline void console_back (void)
 774{
 775        console_col--;
 776
 777        if (console_col < 0) {
 778                console_col = CONSOLE_COLS - 1;
 779                console_row--;
 780                if (console_row < 0)
 781                        console_row = 0;
 782        }
 783
 784        video_putchar ( console_col * VIDEO_FONT_WIDTH,
 785                        console_row * VIDEO_FONT_HEIGHT, ' ');
 786}
 787
 788static inline void console_newline (void)
 789{
 790        console_row++;
 791        console_col = 0;
 792
 793        /* Check if we need to scroll the terminal */
 794        if (console_row >= CONSOLE_ROWS) {
 795                /* Scroll everything up */
 796                console_scrollup ();
 797
 798                /* Decrement row number */
 799                console_row--;
 800        }
 801}
 802
 803void video_putc(struct stdio_dev *dev, const char c)
 804{
 805        if (!video_enable) {
 806                serial_putc (c);
 807                return;
 808        }
 809
 810        switch (c) {
 811        case 13:                        /* Simply ignore this */
 812                break;
 813
 814        case '\n':                      /* Next line, please */
 815                console_newline ();
 816                break;
 817
 818        case 9:                         /* Tab (8 chars alignment) */
 819                console_col |= 0x0008;  /* Next 8 chars boundary */
 820                console_col &= ~0x0007; /* Set this bit to zero */
 821
 822                if (console_col >= CONSOLE_COLS)
 823                        console_newline ();
 824                break;
 825
 826        case 8:                         /* Eat last character */
 827                console_back ();
 828                break;
 829
 830        default:                        /* Add to the console */
 831                video_putchar ( console_col * VIDEO_FONT_WIDTH,
 832                                console_row * VIDEO_FONT_HEIGHT, c);
 833                console_col++;
 834                /* Check if we need to go to next row */
 835                if (console_col >= CONSOLE_COLS)
 836                        console_newline ();
 837        }
 838}
 839
 840void video_puts(struct stdio_dev *dev, const char *s)
 841{
 842        int count = strlen (s);
 843
 844        if (!video_enable)
 845                while (count--)
 846                        serial_putc (*s++);
 847        else
 848                while (count--)
 849                        video_putc(dev, *s++);
 850}
 851
 852/************************************************************************/
 853/* ** CURSOR BLINKING FUNCTIONS                                         */
 854/************************************************************************/
 855
 856#ifdef VIDEO_BLINK
 857
 858#define BLINK_TIMER_ID          0
 859#define BLINK_TIMER_HZ          2
 860
 861static unsigned char blink_enabled = 0;
 862static timer_t blink_timer;
 863
 864static void blink_update (void)
 865{
 866        static int blink_row = -1, blink_col = -1, blink_old = 0;
 867
 868        /* Check if we have a new position to invert */
 869        if ((console_row != blink_row) || (console_col != blink_col)) {
 870                /* Check if we need to reverse last character */
 871                if (blink_old)
 872                        video_revchar ( blink_col * VIDEO_FONT_WIDTH,
 873                                        (blink_row
 874#ifdef CONFIG_VIDEO_LOGO
 875                                         + VIDEO_LOGO_HEIGHT
 876#endif
 877                                        ) * VIDEO_FONT_HEIGHT);
 878
 879                /* Update values */
 880                blink_row = console_row;
 881                blink_col = console_col;
 882                blink_old = 0;
 883        }
 884
 885/* Reverse this character */
 886        blink_old = !blink_old;
 887        video_revchar ( console_col * VIDEO_FONT_WIDTH,
 888                        (console_row
 889#ifdef CONFIG_VIDEO_LOGO
 890                        + VIDEO_LOGO_HEIGHT
 891#endif
 892                        ) * VIDEO_FONT_HEIGHT);
 893
 894}
 895
 896/*
 897 * Handler for blinking cursor
 898 */
 899static void blink_handler (void *arg)
 900{
 901/* Blink */
 902        blink_update ();
 903/* Ack the timer */
 904        timer_ack (&blink_timer);
 905}
 906
 907int blink_set (int blink)
 908{
 909        int ret = blink_enabled;
 910
 911        if (blink)
 912                timer_enable (&blink_timer);
 913        else
 914                timer_disable (&blink_timer);
 915
 916        blink_enabled = blink;
 917
 918        return ret;
 919}
 920
 921static inline void blink_close (void)
 922{
 923        timer_close (&blink_timer);
 924}
 925
 926static inline void blink_init (void)
 927{
 928        timer_init (&blink_timer,
 929                        BLINK_TIMER_ID, BLINK_TIMER_HZ,
 930                        blink_handler);
 931}
 932#endif
 933
 934/************************************************************************/
 935/* ** LOGO PLOTTING FUNCTIONS                                           */
 936/************************************************************************/
 937
 938#ifdef CONFIG_VIDEO_LOGO
 939void easylogo_plot (fastimage_t * image, void *screen, int width, int x,
 940                                        int y)
 941{
 942        int skip = width - image->width, xcount, ycount = image->height;
 943
 944#ifdef VIDEO_MODE_YUYV
 945        ushort *source = (ushort *) image->data;
 946        ushort *dest   = (ushort *) screen + y * width + x;
 947
 948        while (ycount--) {
 949                xcount = image->width;
 950                while (xcount--)
 951                        *dest++ = *source++;
 952                dest += skip;
 953        }
 954#endif
 955#ifdef VIDEO_MODE_RGB
 956        unsigned char
 957        *source = (unsigned short *) image->data,
 958                        *dest = (unsigned short *) screen + ((y * width) + x) * 3;
 959
 960        while (ycount--) {
 961                xcount = image->width * 3;
 962                memcpy (dest, source, xcount);
 963                source += xcount;
 964                dest += ycount;
 965        }
 966#endif
 967}
 968
 969static void *video_logo (void)
 970{
 971        u16 *screen = video_fb_address, width = VIDEO_COLS;
 972#ifdef VIDEO_INFO
 973        char temp[32];
 974        char info[80];
 975#endif /* VIDEO_INFO */
 976
 977        easylogo_plot (VIDEO_LOGO_ADDR, screen, width, 0, 0);
 978
 979#ifdef VIDEO_INFO
 980        sprintf (info, "%s (%s - %s) ",
 981                 U_BOOT_VERSION, U_BOOT_DATE, U_BOOT_TIME);
 982        video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y, info);
 983
 984        strcpy(info, "(C) 2002 DENX Software Engineering");
 985        video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y + VIDEO_FONT_HEIGHT,
 986                                        info);
 987
 988        strcpy(info, "    Wolfgang DENK, wd@denx.de");
 989        video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y + VIDEO_FONT_HEIGHT * 2,
 990                                        info);
 991
 992        /* leave one blank line */
 993
 994        sprintf(info, "MPC823 CPU at %s MHz, %ld MiB RAM, %ld MiB Flash",
 995                strmhz(temp, gd->cpu_clk),
 996                gd->ram_size >> 20,
 997                gd->bd->bi_flashsize >> 20 );
 998        video_drawstring (VIDEO_INFO_X, VIDEO_INFO_Y + VIDEO_FONT_HEIGHT * 4,
 999                                        info);
1000#endif

1001
1002        return video_fb_address + VIDEO_LOGO_HEIGHT * VIDEO_LINE_LEN;
1003}
1004#endif
1005
1006/************************************************************************/
1007/* ** VIDEO HIGH-LEVEL FUNCTIONS                                        */
1008/************************************************************************/
1009
1010static int video_init (void *videobase)
1011{
1012        /* Initialize the encoder */
1013        debug ("[VIDEO] Initializing video encoder...\n");
1014        video_encoder_init ();
1015
1016        /* Initialize the video controller */
1017        debug ("[VIDEO] Initializing video controller at %08x...\n",
1018                   (int) videobase);
1019        video_ctrl_init (videobase);
1020
1021        /* Setting the palette */
1022        video_setpalette  (CONSOLE_COLOR_BLACK,      0,    0,    0);
1023        video_setpalette  (CONSOLE_COLOR_RED,     0xFF,    0,    0);
1024        video_setpalette  (CONSOLE_COLOR_GREEN,      0, 0xFF,    0);
1025        video_setpalette  (CONSOLE_COLOR_YELLOW,  0xFF, 0xFF,    0);
1026        video_setpalette  (CONSOLE_COLOR_BLUE,       0,    0, 0xFF);
1027        video_setpalette  (CONSOLE_COLOR_MAGENTA, 0xFF,    0, 0xFF);
1028        video_setpalette  (CONSOLE_COLOR_CYAN,       0, 0xFF, 0xFF);
1029        video_setpalette  (CONSOLE_COLOR_GREY,    0xAA, 0xAA, 0xAA);
1030        video_setpalette  (CONSOLE_COLOR_GREY2,   0xF8, 0xF8, 0xF8);
1031        video_setpalette  (CONSOLE_COLOR_WHITE,   0xFF, 0xFF, 0xFF);
1032
1033#ifndef CONFIG_SYS_WHITE_ON_BLACK
1034        video_setfgcolor (CONSOLE_COLOR_BLACK);
1035        video_setbgcolor (CONSOLE_COLOR_GREY2);
1036#else
1037        video_setfgcolor (CONSOLE_COLOR_GREY2);
1038        video_setbgcolor (CONSOLE_COLOR_BLACK);
1039#endif  /* CONFIG_SYS_WHITE_ON_BLACK */
1040
1041#ifdef CONFIG_VIDEO_LOGO
1042        /* Paint the logo and retrieve tv base address */
1043        debug ("[VIDEO] Drawing the logo...\n");
1044        video_console_address = video_logo ();
1045#else
1046        video_console_address = video_fb_address;
1047#endif
1048
1049#ifdef VIDEO_BLINK
1050        /* Enable the blinking (under construction) */
1051        blink_init ();
1052        blink_set (0);                          /* To Fix! */
1053#endif
1054
1055        /* Initialize the console */
1056        console_col = 0;
1057        console_row = 0;
1058        video_enable = 1;
1059
1060#ifdef VIDEO_MODE_PAL
1061# define VIDEO_MODE_TMP1        "PAL"
1062#endif
1063#ifdef VIDEO_MODE_NTSC
1064# define VIDEO_MODE_TMP1        "NTSC"
1065#endif
1066#ifdef VIDEO_MODE_YUYV
1067# define VIDEO_MODE_TMP2        "YCbYCr"
1068#endif
1069#ifdef VIDEO_MODE_RGB
1070# define VIDEO_MODE_TMP2        "RGB"
1071#endif
1072        debug ( VIDEO_MODE_TMP1
1073                " %dx%dx%d (" VIDEO_MODE_TMP2 ") on %s - console %dx%d\n",
1074                        VIDEO_COLS, VIDEO_ROWS, VIDEO_MODE_BPP,
1075                        VIDEO_ENCODER_NAME, CONSOLE_COLS, CONSOLE_ROWS);
1076        return 0;
1077}
1078
1079int drv_video_init (void)
1080{
1081        int error, devices = 1;
1082
1083        struct stdio_dev videodev;
1084
1085        video_init ((void *)(gd->fb_base));     /* Video initialization */
1086
1087/* Device initialization */
1088
1089        memset (&videodev, 0, sizeof (videodev));
1090
1091        strcpy (videodev.name, "video");
1092        videodev.flags = DEV_FLAGS_OUTPUT;      /* Output only */
1093        videodev.putc = video_putc;     /* 'putc' function */
1094        videodev.puts = video_puts;     /* 'puts' function */
1095
1096        error = stdio_register (&videodev);
1097
1098        return (error == 0) ? devices : error;
1099}
1100
1101/************************************************************************/
1102/* ** ROM capable initialization part - needed to reserve FB memory     */
1103/************************************************************************/
1104
1105/*
1106 * This is called early in the system initialization to grab memory
1107 * for the video controller.
1108 * Returns new address for monitor, after reserving video buffer memory
1109 *
1110 * Note that this is running from ROM, so no write access to global data.
1111 */
1112ulong video_setmem (ulong addr)
1113{
1114        /* Allocate pages for the frame buffer. */
1115        addr -= VIDEO_SIZE;
1116
1117        debug ("Reserving %dk for Video Framebuffer at: %08lx\n",
1118                VIDEO_SIZE>>10, addr);
1119
1120        return (addr);
1121}
1122
1123#endif
1124