drivers/video/smiLynxEM.c

   1 /*
   2  * (C) Copyright 1997-2002 ELTEC Elektronik AG
   3  * Frank Gottschling <fgottschling@eltec.de>
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /*
  25  * smiLynxEM.c
  26  *
  27  * Silicon Motion graphic interface for sm810/sm710/sm712 accelerator
  28  *
  29  * modification history
  30  * --------------------
  31  * 04-18-2002 Rewritten for U-Boot <fgottschling@eltec.de>.
  32  *
  33  * 18-03-2004 - Unify videomodes handling with the ct69000
  34  *            - The video output can be set via the variable "videoout"
  35  *              in the environment.
  36  *              videoout=1 output on LCD
  37  *              videoout=2 output on CRT (default value)
  38  *                      <p.aubert@staubli.com>
  39  */
  40
  41 #include <common.h>
  42
  43 #include <pci.h>
  44 #include <video_fb.h>
  45 #include "videomodes.h"
  46 /*
  47  * Export Graphic Device
  48  */
  49 GraphicDevice smi;
  50
  51 /*
  52  * SMI 710/712 have 4MB internal RAM; SMI 810 2MB internal + 2MB external
  53  */
  54 #define VIDEO_MEM_SIZE  0x400000
  55
  56
  57 /*
  58  * ISA mapped regs
  59  */
  60 #define SMI_INDX_C4             (pGD->isaBase + 0x03c4)    /* index reg */
  61 #define SMI_DATA_C5             (pGD->isaBase + 0x03c5)    /* data reg */
  62 #define SMI_INDX_D4             (pGD->isaBase + 0x03d4)    /* index reg */
  63 #define SMI_DATA_D5             (pGD->isaBase + 0x03d5)    /* data reg */
  64 #define SMI_ISR1                (pGD->isaBase + 0x03ca)
  65 #define SMI_INDX_CE             (pGD->isaBase + 0x03ce)    /* index reg */
  66 #define SMI_DATA_CF             (pGD->isaBase + 0x03cf)    /* data reg */
  67 #define SMI_LOCK_REG            (pGD->isaBase + 0x03c3)    /* unlock/lock ext crt reg */
  68 #define SMI_MISC_REG            (pGD->isaBase + 0x03c2)    /* misc reg */
  69 #define SMI_LUT_MASK            (pGD->isaBase + 0x03c6)    /* lut mask reg */
  70 #define SMI_LUT_START           (pGD->isaBase + 0x03c8)    /* lut start index */
  71 #define SMI_LUT_RGB             (pGD->isaBase + 0x03c9)    /* lut colors auto incr.*/
  72 #define SMI_INDX_ATTR           (pGD->isaBase + 0x03c0)    /* attributes index reg */
  73
  74 /*
  75  * Video processor control
  76  */
  77 typedef struct {
  78         unsigned int   control;
  79         unsigned int   colorKey;
  80         unsigned int   colorKeyMask;
  81         unsigned int   start;
  82         unsigned short offset;
  83         unsigned short width;
  84         unsigned int   fifoPrio;
  85         unsigned int   fifoERL;
  86         unsigned int   YUVtoRGB;
  87 } SmiVideoProc;
  88
  89 /*
  90  * Video window control
  91  */
  92 typedef struct {
  93         unsigned short top;
  94         unsigned short left;
  95         unsigned short bottom;
  96         unsigned short right;
  97         unsigned int   srcStart;
  98         unsigned short width;
  99         unsigned short offset;
 100         unsigned char  hStretch;
 101         unsigned char  vStretch;
 102 } SmiVideoWin;
 103
 104 /*
 105  * Capture port control
 106  */
 107 typedef struct {
 108         unsigned int   control;
 109         unsigned short topClip;
 110         unsigned short leftClip;
 111         unsigned short srcHeight;
 112         unsigned short srcWidth;
 113         unsigned int   srcBufStart1;
 114         unsigned int   srcBufStart2;
 115         unsigned short srcOffset;
 116         unsigned short fifoControl;
 117 } SmiCapturePort;
 118
 119
 120 /*
 121  * Register values for common video modes
 122  */
 123 static char SMI_SCR[] = {
 124         /* all modes */
 125         0x10, 0xff, 0x11, 0xff, 0x12, 0xff, 0x13, 0xff, 0x15, 0x90,
 126         0x17, 0x20, 0x18, 0xb1, 0x19, 0x00,
 127 };
 128 static char SMI_EXT_CRT[] = {
 129         0x31, 0x00, 0x32, 0x00, 0x33, 0x00, 0x34, 0x00, 0x35, 0x00,
 130         0x36, 0x00, 0x3b, 0x00, 0x3c, 0x00, 0x3d, 0x00, 0x3e, 0x00, 0x3f, 0x00,
 131 };
 132 static char SMI_ATTR [] = {
 133         0x00, 0x00, 0x01, 0x01, 0x02, 0x02, 0x03, 0x03, 0x04, 0x04, 0x05, 0x05,
 134         0x06, 0x06, 0x07, 0x07, 0x08, 0x08, 0x09, 0x09, 0x0a, 0x0a, 0x0b, 0x0b,
 135         0x0c, 0x0c, 0x0d, 0x0d, 0x0e, 0x0e, 0x0f, 0x0f, 0x10, 0x41, 0x11, 0x00,
 136         0x12, 0x0f, 0x13, 0x00, 0x14, 0x00,
 137 };
 138 static char SMI_GCR[18] = {
 139         0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x05, 0x40,
 140         0x06, 0x05, 0x07, 0x0f, 0x08, 0xff,
 141 };
 142 static char SMI_SEQR[] = {
 143         0x00, 0x00, 0x01, 0x01, 0x02, 0x0f, 0x03, 0x03, 0x04, 0x0e, 0x00, 0x03,
 144 };
 145 static char SMI_PCR [] = {
 146         0x20, 0x04, 0x21, 0x30, 0x22, 0x00, 0x23, 0x00, 0x24, 0x00,
 147 };
 148 static char SMI_MCR[] = {
 149         0x60, 0x01, 0x61, 0x00,
 150 #ifdef CONFIG_HMI1001
 151         0x62, 0x74, /* Memory type is not configured by pins on HMI1001 */
 152 #endif
 153 };
 154
 155 static char SMI_HCR[] = {
 156         0x80, 0xff, 0x81, 0x07, 0x82, 0x00, 0x83, 0xff, 0x84, 0xff, 0x88, 0x00,
 157         0x89, 0x02, 0x8a, 0x80, 0x8b, 0x01, 0x8c, 0xff, 0x8d, 0x00,
 158 };
 159
 160
 161 /*******************************************************************************
 162  *
 163  * Write SMI ISA register
 164  */
 165 static void smiWrite (unsigned short index, char reg, char val)
 166 {
 167         register GraphicDevice *pGD = (GraphicDevice *)&smi;
 168
 169         out8 ((pGD->isaBase + index), reg);
 170         out8 ((pGD->isaBase + index + 1), val);
 171 }
 172
 173 /*******************************************************************************
 174  *
 175  * Write a table of SMI ISA register
 176  */
 177 static void smiLoadRegs (
 178         unsigned int iReg,
 179         unsigned int dReg,
 180         char         *regTab,
 181         unsigned int tabSize
 182         )
 183 {
 184         register GraphicDevice *pGD  = (GraphicDevice *)&smi;
 185         register int i;
 186
 187         for (i=0; i<tabSize; i+=2) {
 188                 if (iReg == SMI_INDX_ATTR) {
 189                         /* Reset the Flip Flop */
 190                         in8 (SMI_ISR1);
 191                         out8 (iReg, regTab[i]);
 192                         out8 (iReg, regTab[i+1]);
 193                 } else {
 194                         out8 (iReg, regTab[i]);
 195                         out8 (dReg, regTab[i+1]);
 196                 }
 197         }
 198 }
 199
 200 /*******************************************************************************
 201  *
 202  * Init capture port registers
 203  */
 204 static void smiInitCapturePort (void)
 205 {
 206         SmiCapturePort smiCP = { 0x01400600, 0x30, 0x40, 480, 640, 0, 0, 2560, 6 };
 207         register GraphicDevice *pGD  = (GraphicDevice *)&smi;
 208         register SmiCapturePort *pCP = (SmiCapturePort *)&smiCP;
 209
 210         out32r ((pGD->cprBase + 0x0004), ((pCP->topClip<<16)   | pCP->leftClip));
 211         out32r ((pGD->cprBase + 0x0008), ((pCP->srcHeight<<16) | pCP->srcWidth));
 212         out32r ((pGD->cprBase + 0x000c), pCP->srcBufStart1/8);
 213         out32r ((pGD->cprBase + 0x0010), pCP->srcBufStart2/8);
 214         out32r ((pGD->cprBase + 0x0014), pCP->srcOffset/8);
 215         out32r ((pGD->cprBase + 0x0018), pCP->fifoControl);
 216         out32r ((pGD->cprBase + 0x0000), pCP->control);
 217 }
 218
 219
 220 /*******************************************************************************
 221  *
 222  * Init video processor registers
 223  */
 224 static void smiInitVideoProcessor (void)
 225 {
 226         SmiVideoProc smiVP = { 0x100000, 0, 0, 0, 0, 1600, 0x1200543, 4, 0xededed };
 227         SmiVideoWin  smiVW = { 0, 0, 599, 799, 0, 1600, 0, 0, 0 };
 228         register GraphicDevice *pGD = (GraphicDevice *)&smi;
 229         register SmiVideoProc  *pVP = (SmiVideoProc *)&smiVP;
 230         register SmiVideoWin *pVWin = (SmiVideoWin *)&smiVW;
 231
 232         pVP->width    = pGD->plnSizeX * pGD->gdfBytesPP;
 233         pVP->control |= pGD->gdfIndex << 16;
 234         pVWin->bottom = pGD->winSizeY - 1;
 235         pVWin->right  = pGD->winSizeX - 1;
 236         pVWin->width  = pVP->width;
 237
 238         /* color key */
 239         out32r ((pGD->vprBase + 0x0004), pVP->colorKey);
 240
 241         /* color key mask */
 242         out32r ((pGD->vprBase + 0x0008), pVP->colorKeyMask);
 243
 244         /* data src start adrs */
 245         out32r ((pGD->vprBase + 0x000c), pVP->start / 8);
 246
 247         /* data width and offset */
 248         out32r ((pGD->vprBase + 0x0010),
 249                 ((pVP->offset   / 8 * pGD->gdfBytesPP) << 16) |
 250                 (pGD->plnSizeX / 8 * pGD->gdfBytesPP));
 251
 252         /* video window 1 */
 253         out32r ((pGD->vprBase + 0x0014),
 254                 ((pVWin->top << 16) | pVWin->left));
 255
 256         out32r ((pGD->vprBase + 0x0018),
 257                 ((pVWin->bottom << 16) | pVWin->right));
 258
 259         out32r ((pGD->vprBase + 0x001c), pVWin->srcStart / 8);
 260
 261         out32r ((pGD->vprBase + 0x0020),
 262                 (((pVWin->offset / 8) << 16) | (pVWin->width / 8)));
 263
 264         out32r ((pGD->vprBase + 0x0024),
 265                 (((pVWin->hStretch) << 8) | pVWin->vStretch));
 266
 267         /* video window 2 */
 268         out32r ((pGD->vprBase + 0x0028),
 269                 ((pVWin->top << 16) | pVWin->left));
 270
 271         out32r ((pGD->vprBase + 0x002c),
 272                 ((pVWin->bottom << 16) | pVWin->right));
 273
 274         out32r ((pGD->vprBase + 0x0030),
 275                 pVWin->srcStart / 8);
 276
 277         out32r ((pGD->vprBase + 0x0034),
 278                 (((pVWin->offset / 8) << 16) | (pVWin->width / 8)));
 279
 280         out32r ((pGD->vprBase + 0x0038),
 281                 (((pVWin->hStretch) << 8) | pVWin->vStretch));
 282
 283         /* fifo prio control */
 284         out32r ((pGD->vprBase + 0x0054), pVP->fifoPrio);
 285
 286         /* fifo empty request levell */
 287         out32r ((pGD->vprBase + 0x0058), pVP->fifoERL);
 288
 289         /* conversion constant */
 290         out32r ((pGD->vprBase + 0x005c), pVP->YUVtoRGB);
 291
 292         /* vpr control word */
 293         out32r ((pGD->vprBase + 0x0000), pVP->control);
 294 }
 295
 296 /******************************************************************************
 297  *
 298  * Init drawing engine registers
 299  */
 300 static void smiInitDrawingEngine (void)
 301 {
 302         GraphicDevice *pGD = (GraphicDevice *)&smi;
 303         unsigned int val;
 304
 305         /* don't start now */
 306         out32r ((pGD->dprBase + 0x000c), 0x000f0000);
 307
 308         /* set rop2 to copypen */
 309         val = 0xffff3ff0 & in32r ((pGD->dprBase + 0x000c));
 310         out32r ((pGD->dprBase + 0x000c), (val | 0x8000 | 0x0c));
 311
 312         /* set clip rect */
 313         out32r ((pGD->dprBase + 0x002c), 0);
 314         out32r ((pGD->dprBase + 0x0030),
 315                 ((pGD->winSizeY<<16) | pGD->winSizeX * pGD->gdfBytesPP ));
 316
 317         /* src row pitch */
 318         val = 0xffff0000 & (in32r ((pGD->dprBase + 0x0010)));
 319         out32r ((pGD->dprBase + 0x0010),
 320                 (val | pGD->plnSizeX * pGD->gdfBytesPP));
 321
 322         /* dst row pitch */
 323         val = 0x0000ffff & (in32r ((pGD->dprBase + 0x0010)));
 324         out32r ((pGD->dprBase + 0x0010),
 325                 (((pGD->plnSizeX * pGD->gdfBytesPP)<<16) | val));
 326
 327         /* window width src/dst */
 328         out32r ((pGD->dprBase + 0x003c),
 329                 (((pGD->plnSizeX * pGD->gdfBytesPP & 0x0fff)<<16) |
 330                  (pGD->plnSizeX * pGD->gdfBytesPP & 0x0fff)));
 331         out16r ((pGD->dprBase + 0x001e), 0x0000);
 332
 333         /* src base adrs */
 334         out32r ((pGD->dprBase + 0x0040),
 335                 (((pGD->frameAdrs/8) & 0x000fffff)));
 336
 337         /* dst base adrs */
 338         out32r ((pGD->dprBase + 0x0044),
 339                 (((pGD->frameAdrs/8) & 0x000fffff)));
 340
 341         /* foreground color */
 342         out32r ((pGD->dprBase + 0x0014), pGD->fg);
 343
 344         /* background color */
 345         out32r ((pGD->dprBase + 0x0018), pGD->bg);
 346
 347         /* xcolor */
 348         out32r ((pGD->dprBase + 0x0020), 0x00ffffff);
 349
 350         /* xcolor mask */
 351         out32r ((pGD->dprBase + 0x0024), 0x00ffffff);
 352
 353         /* bit mask */
 354         out32r ((pGD->dprBase + 0x0028), 0x00ffffff);
 355
 356         /* load mono pattern */
 357         out32r ((pGD->dprBase + 0x0034), 0);
 358         out32r ((pGD->dprBase + 0x0038), 0);
 359 }
 360
 361 static struct pci_device_id supported[] = {
 362         { PCI_VENDOR_ID_SMI, PCI_DEVICE_ID_SMI_710 },
 363         { PCI_VENDOR_ID_SMI, PCI_DEVICE_ID_SMI_712 },
 364         { PCI_VENDOR_ID_SMI, PCI_DEVICE_ID_SMI_810 },
 365         { }
 366 };
 367
 368 /*****************************************************************************/
 369 static void smiLoadMsr (struct ctfb_res_modes *mode)
 370 {
 371         unsigned char h_synch_high, v_synch_high;
 372         register GraphicDevice *pGD  = (GraphicDevice *)&smi;
 373
 374         h_synch_high = (mode->sync & FB_SYNC_HOR_HIGH_ACT) ? 0 : 0x40;  /* horizontal Synch High active */
 375         v_synch_high = (mode->sync & FB_SYNC_VERT_HIGH_ACT) ? 0 : 0x80; /* vertical Synch High active */
 376         out8 (SMI_MISC_REG, (h_synch_high | v_synch_high | 0x29));
 377         /* upper64K==0x20, CLC2select==0x08, RAMenable==0x02!(todo), CGA==0x01
 378          * Selects the upper 64KB page.Bit5=1
 379          * CLK2 (left reserved in standard VGA) Bit3|2=1|0
 380          * Disables CPU access to frame buffer. Bit1=0
 381          * Sets the I/O address decode for ST01, FCR, and all CR registers
 382          * to the 3Dx I/O address range (CGA emulation). Bit0=1
 383          */
 384 }
 385 /*****************************************************************************/
 386 static void smiLoadCrt (struct ctfb_res_modes *var, int bits_per_pixel)
 387 {
 388         unsigned char cr[0x7a];
 389         int i;
 390         unsigned int hd, hs, he, ht, hbs, hbe;  /* Horizontal.  */
 391         unsigned int vd, vs, ve, vt, vbs, vbe;  /* vertical */
 392         unsigned int bpp, wd, dblscan, interlaced;
 393
 394         const int LineCompare = 0x3ff;
 395         unsigned int TextScanLines = 1; /* this is in fact a vertical zoom factor   */
 396         register GraphicDevice *pGD  = (GraphicDevice *)&smi;
 397
 398         /* Horizontal */
 399         hd = (var->xres) / 8;   /* HDisp.  */
 400         hs = (var->xres + var->right_margin) / 8;       /* HsStrt  */
 401         he = (var->xres + var->right_margin + var->hsync_len) / 8;      /* HsEnd   */
 402         ht = (var->left_margin + var->xres + var->right_margin + var->hsync_len) / 8;   /* HTotal  */
 403         /* Blank */
 404         hbs = hd;
 405         hbe = 0; /* Blank end at 0 */
 406
 407         /* Vertical */
 408         vd = var->yres;         /* VDisplay   */
 409         vs = var->yres + var->lower_margin;     /* VSyncStart */
 410         ve = var->yres + var->lower_margin + var->vsync_len;    /* VSyncEnd */
 411         vt = var->upper_margin + var->yres + var->lower_margin + var->vsync_len;        /* VTotal  */
 412         vbs = vd;
 413         vbe = 0;
 414
 415         bpp = bits_per_pixel;
 416         dblscan = (var->vmode & FB_VMODE_DOUBLE) ? 1 : 0;
 417         interlaced = var->vmode & FB_VMODE_INTERLACED;
 418
 419
 420         if (bpp == 15)
 421                 bpp = 16;
 422         wd = var->xres * bpp / 64;      /* double words per line */
 423         if (interlaced) {       /* we divide all vertical timings, exept vd */
 424                 vs >>= 1;
 425                 vbs >>= 1;
 426                 ve >>= 1;
 427                 vt >>= 1;
 428         }
 429
 430         memset (cr, 0, sizeof (cr));
 431         cr[0x00] = ht - 5;
 432         cr[0x01] = hd - 1;
 433         cr[0x02] = hbs - 1;
 434         cr[0x03] = (hbe & 0x1F);
 435         cr[0x04] = hs;
 436         cr[0x05] = ((hbe & 0x20) << 2) | (he & 0x1f);
 437
 438         cr[0x06] = (vt - 2) & 0xFF;
 439         cr[0x07] = (((vt - 2) & 0x100) >> 8)
 440                 | (((vd - 1) & 0x100) >> 7)
 441                 | ((vs & 0x100) >> 6)
 442                 | (((vbs - 1) & 0x100) >> 5)
 443                 | ((LineCompare & 0x100) >> 4)
 444                 | (((vt - 2) & 0x200) >> 4)
 445                 | (((vd - 1) & 0x200) >> 3)
 446                 | ((vs & 0x200) >> 2);
 447
 448         cr[0x30] = ((vt - 2) & 0x400) >> 7
 449                 | (((vd - 1) & 0x400) >> 8)
 450                 | (((vbs - 1) & 0x400) >> 9)
 451                 | ((vs & 0x400) >> 10)
 452                 | (interlaced) ? 0x80 : 0;
 453
 454
 455         cr[0x08] = 0x00;
 456         cr[0x09] = (dblscan << 7)
 457                 | ((LineCompare & 0x200) >> 3)
 458                 | (((vbs - 1) & 0x200) >> 4)
 459                 | (TextScanLines - 1);
 460
 461         cr[0x10] = vs & 0xff;   /* VSyncPulseStart */
 462         cr[0x11] = (ve & 0x0f);
 463         cr[0x12] = (vd - 1) & 0xff;     /* LineCount  */
 464         cr[0x13] = wd & 0xff;
 465         cr[0x14] = 0x40;
 466         cr[0x15] = (vbs - 1) & 0xff;
 467         cr[0x16] = vbe & 0xff;
 468         cr[0x17] = 0xe3;        /* but it does not work */
 469         cr[0x18] = 0xff & LineCompare;
 470         cr[0x22] = 0x00;        /* todo? */
 471
 472
 473         /* now set the registers */
 474         for (i = 0; i <= 0x18; i++) {   /*CR00 .. CR18 */
 475                 smiWrite (SMI_INDX_D4, i, cr[i]);
 476         }
 477         i = 0x22;               /*CR22 */
 478         smiWrite (SMI_INDX_D4, i, cr[i]);
 479         i = 0x30;               /*CR30 */
 480         smiWrite (SMI_INDX_D4, i, cr[i]);
 481 }
 482
 483 /*****************************************************************************/
 484 #define REF_FREQ        14318180
 485 #define PMIN            1
 486 #define PMAX            255
 487 #define QMIN            1
 488 #define QMAX            63
 489
 490 static unsigned int FindPQ (unsigned int freq, unsigned int *pp, unsigned int *pq)
 491 {
 492         unsigned int n = QMIN, m = 0;
 493         long long int L = 0, P = freq, Q = REF_FREQ, H = P >> 1;
 494         long long int D = 0x7ffffffffffffffLL;
 495
 496         for (n = QMIN; n <= QMAX; n++) {
 497                 m = PMIN;       /* p/q ~ freq/ref -> p*ref-freq*q ~ 0 */
 498                 L = P * n - m * Q;
 499                 while (L > 0 && m < PMAX) {
 500                         L -= REF_FREQ;  /* difference is greater as 0 subtract fref */
 501                         m++;    /* and increment m */
 502                 }
 503                 /* difference is less or equal than 0 or m > maximum */
 504                 if (m > PMAX)
 505                         break;  /* no solution: if we increase n we get the same situation */
 506                 /* L is <= 0 now */
 507                 if (-L > H && m > PMIN) {       /* if difference > the half fref */
 508                         L += REF_FREQ;  /* we take the situation before */
 509                         m--;    /* because its closer to 0 */
 510                 }
 511                 L = (L < 0) ? -L : +L;  /* absolute value */
 512                 if (D < L)      /* if last difference was better take next n */
 513                         continue;
 514                 D = L;
 515                 *pp = m;
 516                 *pq = n;        /*  keep improved data */
 517                 if (D == 0)
 518                         break;  /* best result we can get */
 519         }
 520         return (unsigned int) (0xffffffff & D);
 521 }
 522
 523 /*****************************************************************************/
 524 static void smiLoadCcr (struct ctfb_res_modes *var, unsigned short device_id)
 525 {
 526         unsigned int p = 0;
 527         unsigned int q = 0;
 528         long long freq;
 529         register GraphicDevice *pGD  = (GraphicDevice *)&smi;
 530
 531         smiWrite (SMI_INDX_C4, 0x65, 0);
 532         smiWrite (SMI_INDX_C4, 0x66, 0);
 533         smiWrite (SMI_INDX_C4, 0x68, 0x50);
 534         if (device_id == PCI_DEVICE_ID_SMI_810) {
 535                 smiWrite (SMI_INDX_C4, 0x69, 0x3);
 536         } else {
 537                 smiWrite (SMI_INDX_C4, 0x69, 0x0);
 538         }
 539
 540         /* Memory clock */
 541         switch (device_id) {
 542         case PCI_DEVICE_ID_SMI_710 :
 543                 smiWrite (SMI_INDX_C4, 0x6a, 0x75);
 544                 break;
 545         case PCI_DEVICE_ID_SMI_712 :
 546                 smiWrite (SMI_INDX_C4, 0x6a, 0x80);
 547                 break;
 548         default :
 549                 smiWrite (SMI_INDX_C4, 0x6a, 0x53);
 550                 break;
 551         }
 552         smiWrite (SMI_INDX_C4, 0x6b, 0x15);
 553
 554         /* VCLK */
 555         freq = 1000000000000LL / var -> pixclock;
 556
 557         FindPQ ((unsigned int)freq, &p, &q);
 558
 559         smiWrite (SMI_INDX_C4, 0x6c, p);
 560         smiWrite (SMI_INDX_C4, 0x6d, q);
 561
 562 }
 563
 564 /*******************************************************************************
 565  *
 566  * Init video chip with common Linux graphic modes (lilo)
 567  */
 568 void *video_hw_init (void)
 569 {
 570         GraphicDevice *pGD = (GraphicDevice *)&smi;
 571         unsigned short device_id;
 572         pci_dev_t devbusfn;
 573         int videomode;
 574         unsigned long t1, hsynch, vsynch;
 575         unsigned int pci_mem_base, *vm;
 576         char *penv;
 577         int tmp, i, bits_per_pixel;
 578         struct ctfb_res_modes *res_mode;
 579         struct ctfb_res_modes var_mode;
 580         unsigned char videoout;
 581
 582         /* Search for video chip */
 583         printf("Video: ");
 584
 585         if ((devbusfn = pci_find_devices(supported, 0)) < 0)
 586         {
 587                 printf ("Controller not found !\n");
 588                 return (NULL);
 589         }
 590
 591         /* PCI setup */
 592         pci_write_config_dword (devbusfn, PCI_COMMAND, (PCI_COMMAND_MEMORY | PCI_COMMAND_IO));
 593         pci_read_config_word (devbusfn, PCI_DEVICE_ID, &device_id);
 594         pci_read_config_dword (devbusfn, PCI_BASE_ADDRESS_0, &pci_mem_base);
 595         pci_mem_base = pci_mem_to_phys (devbusfn, pci_mem_base);
 596
 597         tmp = 0;
 598
 599         videomode = CONFIG_SYS_DEFAULT_VIDEO_MODE;
 600         /* get video mode via environment */
 601         if ((penv = getenv ("videomode")) != NULL) {
 602                 /* deceide if it is a string */
 603                 if (penv[0] <= '9') {
 604                         videomode = (int) simple_strtoul (penv, NULL, 16);
 605                         tmp = 1;
 606                 }
 607         } else {
 608                 tmp = 1;
 609         }
 610         if (tmp) {
 611                 /* parameter are vesa modes */
 612                 /* search params */
 613                 for (i = 0; i < VESA_MODES_COUNT; i++) {
 614                         if (vesa_modes[i].vesanr == videomode)
 615                                 break;
 616                 }
 617                 if (i == VESA_MODES_COUNT) {
 618                         printf ("no VESA Mode found, switching to mode 0x%x ", CONFIG_SYS_DEFAULT_VIDEO_MODE);
 619                         i = 0;
 620                 }
 621                 res_mode =
 622                         (struct ctfb_res_modes *) &res_mode_init[vesa_modes[i].
 623                                                                  resindex];
 624                 bits_per_pixel = vesa_modes[i].bits_per_pixel;
 625         } else {
 626
 627                 res_mode = (struct ctfb_res_modes *) &var_mode;
 628                 bits_per_pixel = video_get_params (res_mode, penv);
 629         }
 630
 631         /* calculate hsynch and vsynch freq (info only) */
 632         t1 = (res_mode->left_margin + res_mode->xres +
 633               res_mode->right_margin + res_mode->hsync_len) / 8;
 634         t1 *= 8;
 635         t1 *= res_mode->pixclock;
 636         t1 /= 1000;
 637         hsynch = 1000000000L / t1;
 638         t1 *=
 639                 (res_mode->upper_margin + res_mode->yres +
 640                  res_mode->lower_margin + res_mode->vsync_len);
 641         t1 /= 1000;
 642         vsynch = 1000000000L / t1;
 643
 644         /* fill in Graphic device struct */
 645         sprintf (pGD->modeIdent, "%dx%dx%d %ldkHz %ldHz", res_mode->xres,
 646                  res_mode->yres, bits_per_pixel, (hsynch / 1000),
 647                  (vsynch / 1000));
 648         printf ("%s\n", pGD->modeIdent);
 649         pGD->winSizeX = res_mode->xres;
 650         pGD->winSizeY = res_mode->yres;
 651         pGD->plnSizeX = res_mode->xres;
 652         pGD->plnSizeY = res_mode->yres;
 653         switch (bits_per_pixel) {
 654         case 8:
 655                 pGD->gdfBytesPP = 1;
 656                 pGD->gdfIndex = GDF__8BIT_INDEX;
 657                 break;
 658         case 15:
 659                 pGD->gdfBytesPP = 2;
 660                 pGD->gdfIndex = GDF_15BIT_555RGB;
 661                 break;
 662         case 16:
 663                 pGD->gdfBytesPP = 2;
 664                 pGD->gdfIndex = GDF_16BIT_565RGB;
 665                 break;
 666         case 24:
 667                 pGD->gdfBytesPP = 3;
 668                 pGD->gdfIndex = GDF_24BIT_888RGB;
 669                 break;
 670         }
 671
 672         pGD->isaBase = CONFIG_SYS_ISA_IO;
 673         pGD->pciBase = pci_mem_base;
 674         pGD->dprBase = (pci_mem_base + 0x400000 + 0x8000);
 675         pGD->vprBase = (pci_mem_base + 0x400000 + 0xc000);
 676         pGD->cprBase = (pci_mem_base + 0x400000 + 0xe000);
 677         pGD->frameAdrs = pci_mem_base;
 678         pGD->memSize = VIDEO_MEM_SIZE;
 679
 680         /* Set up hardware : select color mode,
 681            set Register base to isa 3dx for 3?x regs*/
 682         out8 (SMI_MISC_REG, 0x01);
 683
 684         /* Turn off display */
 685         smiWrite (SMI_INDX_C4, 0x01, 0x20);
 686
 687         /* Unlock ext. crt regs */
 688         out8 (SMI_LOCK_REG, 0x40);
 689
 690         /* Unlock crt regs 0-7 */
 691         smiWrite (SMI_INDX_D4, 0x11, 0x0e);
 692
 693         /* Sytem Control Register */
 694         smiLoadRegs (SMI_INDX_C4, SMI_DATA_C5, SMI_SCR, sizeof(SMI_SCR));
 695
 696         /* extented CRT Register */
 697         smiLoadRegs (SMI_INDX_D4, SMI_DATA_D5, SMI_EXT_CRT, sizeof(SMI_EXT_CRT));
 698
 699         /* Attributes controller registers */
 700         smiLoadRegs (SMI_INDX_ATTR, SMI_INDX_ATTR, SMI_ATTR, sizeof(SMI_ATTR));
 701
 702         /* Graphics Controller Register */
 703         smiLoadRegs (SMI_INDX_CE, SMI_DATA_CF, SMI_GCR, sizeof(SMI_GCR));
 704
 705         /* Sequencer Register */
 706         smiLoadRegs (SMI_INDX_C4, SMI_DATA_C5, SMI_SEQR, sizeof(SMI_SEQR));
 707
 708         /* Power Control Register */
 709         smiLoadRegs (SMI_INDX_C4, SMI_DATA_C5, SMI_PCR, sizeof(SMI_PCR));
 710
 711         /* Memory Control Register */
 712         /* Register MSR62 is a power on configurable register. We don't */
 713         /* modify it */
 714         smiLoadRegs (SMI_INDX_C4, SMI_DATA_C5, SMI_MCR, sizeof(SMI_MCR));
 715
 716         /* Set misc output register */
 717         smiLoadMsr (res_mode);
 718
 719         /* Set CRT and Clock control registers */
 720         smiLoadCrt (res_mode, bits_per_pixel);
 721
 722         smiLoadCcr (res_mode, device_id);
 723
 724         /* Hardware Cusor Register */
 725         smiLoadRegs (SMI_INDX_C4, SMI_DATA_C5, SMI_HCR, sizeof(SMI_HCR));
 726
 727         /* Enable  Display  */
 728         videoout = 2;       /* Default output is CRT */
 729         if ((penv = getenv ("videoout")) != NULL) {
 730                 /* deceide if it is a string */
 731                 videoout = (int) simple_strtoul (penv, NULL, 16);
 732         }
 733         smiWrite (SMI_INDX_C4, 0x31, videoout);
 734
 735         /* Video processor default setup */
 736         smiInitVideoProcessor ();
 737
 738         /* Capture port default setup */
 739         smiInitCapturePort ();
 740
 741         /* Drawing engine default setup */
 742         smiInitDrawingEngine ();
 743
 744         /* Turn on display */
 745         smiWrite (0x3c4, 0x01, 0x01);
 746
 747         /* Clear video memory */
 748         i = pGD->memSize/4;
 749         vm = (unsigned int *)pGD->pciBase;
 750         while(i--)
 751                 *vm++ = 0;
 752         return ((void*)&smi);
 753 }
 754
 755 /*******************************************************************************
 756  *
 757  * Drawing engine fill on screen region
 758  */
 759 void video_hw_rectfill (
 760         unsigned int bpp,             /* bytes per pixel */
 761         unsigned int dst_x,           /* dest pos x */
 762         unsigned int dst_y,           /* dest pos y */
 763         unsigned int dim_x,           /* frame width */
 764         unsigned int dim_y,           /* frame height */
 765         unsigned int color            /* fill color */
 766         )
 767 {
 768         register GraphicDevice *pGD = (GraphicDevice *)&smi;
 769         register unsigned int control;
 770
 771         dim_x *= bpp;
 772
 773         out32r ((pGD->dprBase + 0x0014), color);
 774         out32r ((pGD->dprBase + 0x0004), ((dst_x<<16) | dst_y));
 775         out32r ((pGD->dprBase + 0x0008), ((dim_x<<16) | dim_y));
 776
 777         control = 0x0000ffff &  in32r ((pGD->dprBase + 0x000c));
 778
 779         control |= 0x80010000;
 780
 781         out32r ((pGD->dprBase + 0x000c),  control);
 782
 783         /* Wait for drawing processor */
 784         do
 785         {
 786                 out8 ((pGD->isaBase + 0x3c4), 0x16);
 787         } while (in8 (pGD->isaBase + 0x3c5) & 0x08);
 788 }
 789
 790 /*******************************************************************************
 791  *
 792  * Drawing engine bitblt with screen region
 793  */
 794 void video_hw_bitblt (
 795         unsigned int bpp,             /* bytes per pixel */
 796         unsigned int src_x,           /* source pos x */
 797         unsigned int src_y,           /* source pos y */
 798         unsigned int dst_x,           /* dest pos x */
 799         unsigned int dst_y,           /* dest pos y */
 800         unsigned int dim_x,           /* frame width */
 801         unsigned int dim_y            /* frame height */
 802         )
 803 {
 804         register GraphicDevice *pGD = (GraphicDevice *)&smi;
 805         register unsigned int control;
 806
 807         dim_x *= bpp;
 808
 809         if ((src_y<dst_y) || ((src_y==dst_y) && (src_x<dst_x)))
 810         {
 811                 out32r ((pGD->dprBase + 0x0000), (((src_x+dim_x-1)<<16) | (src_y+dim_y-1)));
 812                 out32r ((pGD->dprBase + 0x0004), (((dst_x+dim_x-1)<<16) | (dst_y+dim_y-1)));
 813                 control = 0x88000000;
 814         } else {
 815                 out32r ((pGD->dprBase + 0x0000), ((src_x<<16) | src_y));
 816                 out32r ((pGD->dprBase + 0x0004), ((dst_x<<16) | dst_y));
 817                 control = 0x80000000;
 818         }
 819
 820         out32r ((pGD->dprBase + 0x0008), ((dim_x<<16) | dim_y));
 821         control |= (0x0000ffff &  in32r ((pGD->dprBase + 0x000c)));
 822         out32r ((pGD->dprBase + 0x000c), control);
 823
 824         /* Wait for drawing processor */
 825         do
 826         {
 827                 out8 ((pGD->isaBase + 0x3c4), 0x16);
 828         } while (in8 (pGD->isaBase + 0x3c5) & 0x08);
 829 }
 830
 831 /*******************************************************************************
 832  *
 833  * Set a RGB color in the LUT (8 bit index)
 834  */
 835 void video_set_lut (
 836         unsigned int index,           /* color number */
 837         unsigned char r,              /* red */
 838         unsigned char g,              /* green */
 839         unsigned char b               /* blue */
 840         )
 841 {
 842         register GraphicDevice *pGD = (GraphicDevice *)&smi;
 843
 844         out8 (SMI_LUT_MASK,  0xff);
 845
 846         out8 (SMI_LUT_START, (char)index);
 847
 848         out8 (SMI_LUT_RGB, r>>2);    /* red */
 849         udelay (10);
 850         out8 (SMI_LUT_RGB, g>>2);    /* green */
 851         udelay (10);
 852         out8 (SMI_LUT_RGB, b>>2);    /* blue */
 853         udelay (10);
 854 }