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